# -*- coding: utf-8 -*-
'''
Created on 8/05/2012

@author: EdwarC
'''
from django.core.mail import send_mail, EmailMultiAlternatives
from django.core.context_processors import csrf
from django.contrib.sessions.models import Session
from django.shortcuts import render_to_response, redirect, render
from django.template import RequestContext, loader
from django.http import HttpResponse
from django.views.static import Context, HttpResponseRedirect                       # incorporo para poder acceder a archivos estaticos
from django.conf import settings, Settings
from django.contrib import auth
from django.contrib.auth import authenticate, login                                   
from django.contrib.auth.models import Group, User
from django.contrib.auth.decorators import login_required                           # permite usar @login_requerid
from datetime import date, timedelta
import calendar
import user
from app.models import Configuracion, ConfiguracionUsuario, Categoria, Unidad,\
    Producto, Proveedor, Sede, Inventario, FacturaCompra, FacturaCompraItem,\
    FacturaVenta, FacturaVentaItem, ConfiguracionUsuarioSede, Iva, Traslado,\
    Movimientos, Reintegro, Notificaciones, OrdenFactura, OrdenFacturaItem
from django.db.models import Q
import csv
import urllib2
from urllib2 import URLError, HTTPError
from django.utils.datetime_safe import datetime
from django.contrib.admin.models import LogEntry, ADDITION
from django.contrib.contenttypes.models import ContentType
from django.utils.encoding import force_unicode
from decimal import Decimal
from django.db.models.aggregates import Sum, Max, Min
import os
from django import http

def redireccionar(plantilla, solicitud, datos):
    variables = {
        'user': solicitud.user, 
        'titulo': 'Cristabit',
        'saludo': '',
        'titulo_pagina': u"Cristabit",
        'path': settings.MEDIA_URL,
    }
    llaves = datos.keys()
    for indice in range(0,len(llaves)):
        variables[llaves[indice]] = datos[llaves[indice]]
    variables =  Context(variables)
    return render_to_response(plantilla, variables, context_instance=RequestContext(solicitud))

def indice(solicitud):
    try:
        if(solicitud.session.session_key):
            session = Session.objects.get(session_key=solicitud.session.session_key)
            uid = session.get_decoded().get('_auth_user_id')
            datos = {}
            user_sede = {}
            inv = []
            config_id = solicitud.session['config_id']
            config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=uid)
            
            if config_user>0:
                config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=uid)
                user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)

            configuracion = Configuracion.objects.get(id = config_id)
            notificaciones = Notificaciones.objects.filter(configuracion_id = config_id)
            if len(notificaciones) > 0:
                notificaciones = Notificaciones.objects.get(configuracion_id = config_id)
            else:
                notificaciones = {}
            fecha = date.today() + timedelta(days=30)
            
            categorias = Categoria.objects.filter(configuracion_id=config_id)
            for categoria in categorias:
                productos = Producto.objects.filter(configuracion_id=config_id, categoria_id = categoria.id)
                if categoria.dias_vencimiento>0:
                    fecha = date.today() + timedelta(days=categoria.dias_vencimiento)
                    items = FacturaCompraItem.objects.filter(configuracion_id=config_id, producto__in=productos, fecha_vencimiento__lte=fecha)
#                else:
#                    items = FacturaCompraItem.objects.filter(configuracion_id=config_id, producto__in=productos)
                    inventarios = Inventario.objects.filter(item__in=items, cantidad__gte=1)
#                    for sede in user_sede:
#                        inventarios = inventarios.filter(sede_id = sede.sede_id)
                    
                    for inventario in inventarios:
                        user_inv = user_sede.filter(sede_id = inventario.sede_id)
                        if len(user_inv)>0:
                            inv.append(inventario)
            
            datos = {'Inventario' : inv, 'Configuracion':configuracion, 'envia': user_sede, 'Notificaciones':notificaciones}
            return redireccionar('index.html', solicitud, datos)
        else:
            return redireccionar('index.html', solicitud, {})
    except:
        return redireccionar('index.html', solicitud, {})
    
def recuperarContrasena(solicitud):
    datos = {}
    try:
        if solicitud.method == 'POST':
            usuario = solicitud.POST.get('email')
            mi_usuario = User.objects.filter(username = usuario)
            if mi_usuario:
                contrasena = User.objects.make_random_password(length=10, allowed_chars='abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789')
                user = User.objects.get(username__exact = usuario)
                user.set_password(contrasena)
                texto = "%s %s." %("Se ha restituido su contraseña de acceso a Cristabit. La nueva contraseña es: ", contrasena)
                user.save()
                send_mail('Nueva contraseña de acceso a Cristabit', texto, 'admin@arawak.com.co', [user.email], fail_silently=False)
                datos['msg_error'] = 'Se ha enviado un mensaje a su cuenta de correo electrónico.'
            else:
                datos['msg_error'] = 'El usuario no esta registrado en el sistema.'
            
    except:
        datos['msg_error'] = 'Se ha producido un error enviando el correo electronico. '
    return redireccionar('index.html', solicitud, datos)
    
    
def mylogin(solicitud):
    datos = {}
    if solicitud.method == 'POST':
        username = solicitud.POST['usuario']
        password = solicitud.POST['contrasena']
        user = authenticate(username=username, password=password)
        if user is None:
            datos['msg_error'] = 'Acceso denegado.'
            return redireccionar('index.html', solicitud, datos)
        else:
            configuracion = ConfiguracionUsuario.objects.filter(usuario_id = user.id)
            if len(configuracion)>0:
                if user.is_active:
                    login(solicitud, user)
                    configuracion = ConfiguracionUsuario.objects.get(usuario_id = user.id)
                    solicitud.session['config'] = configuracion
                    solicitud.session['config_id'] = configuracion.configuracion_id
                    return HttpResponseRedirect('/')
                else:
                    datos['msg_error'] = 'El usuario no se encuentra activo.'
                    return redireccionar('index.html', solicitud, datos)
            else:
                datos['msg_error'] = 'El usuario no cuenta con datos de institución en el sistema. Contáctese con el administrador'
                return redireccionar('index.html', solicitud, datos)

def mylogout(solicitud):
    if 'grupoUsuarioId' in solicitud.session:
        del solicitud.session['grupoUsuarioId']
    if 'msg_error' in solicitud.session:
        del solicitud.session['msg_error']
    auth.logout(solicitud)    
    return HttpResponseRedirect("/")


def inGroup(solicitud, grupo=0):
    existe = False
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    usuarios = user.groups.filter(id=grupo)
    if len(usuarios)>0:
        existe = True
    return existe



def enviarMailVencidos(solicitud):
    datos = {}
    texto = ""
    destino = ""
    i  = 0
    notificados = 0
#    try:
    inv = []
    
    configuracion = Configuracion.objects.all()
    for config in configuracion:
        i = 0
        texto = ""
        
        notificaciones = Notificaciones.objects.filter(configuracion_id = config.id)
        if len(notificaciones) > 0:
            notificaciones = Notificaciones.objects.get(configuracion_id = config.id)
            notificados = notificaciones.correo.split(",")
#            texto = len(notificados)
            fecha = date.today() + timedelta(days=30)
            
            categorias = Categoria.objects.filter(configuracion_id=config.id)
            for categoria in categorias:
                productos = Producto.objects.filter(configuracion_id=config.id, categoria_id = categoria.id)
                if categoria.dias_vencimiento>0:
                    fecha = date.today() + timedelta(days=categoria.dias_vencimiento)
                    items = FacturaCompraItem.objects.filter(configuracion_id=config.id, producto__in=productos, fecha_vencimiento__lte=fecha)
                    inventarios = Inventario.objects.filter(item__in=items, cantidad__gte=1)
                    for inv in inventarios:
                        i += 1
                        texto = u"%s <tr><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td><td>%s</td></tr>" \
                            %(texto, inv.item.producto.cum, inv.item.producto.nombre, inv.item.lote, inv.item.factura_compra.numero, inv.sede.nombre, inv.cantidad, inv.item.fecha_vencimiento)
        else:
            notificaciones = {}
            
        if i>0:
            texto = "<table><tr><th>Codigo o Cum</th><th>Nombre</th><th>Lote</th><th>Factura</th><th>Sede</th><th>Unidades</th><th>Vence en:</th></tr>%s</table>" %(texto)
            
            for notif in notificados:
                if len(notif)>1:
                    subject, from_email, to = u"Ítems próximos a vencer.%s." %(config.nombre), 'admin@cristabit.com', notif
                    destino = "%s %s " %(destino, notif)
                    text_content = 'This is an important message.'
                    msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
                    msg.attach_alternative(texto, "text/html")
                    msg.send()
    texto = "El mensaje se ha enviado correctamente a %s destinatarios. %s" %(len(notificados), destino)         
#            datos = {'Inventario' : inv, 'Configuracion':configuracion, 'Notificaciones':notificaciones}
#    except:
#            texto = "Error enviando el email."
    
    return HttpResponse(texto)
    
# ##########################################
# PROVEEDORES
# ##########################################


@login_required
def proveedores(solicitud, texto=""):
    datos={}
    config_id = solicitud.session['config_id']
    proveedores = Proveedor.objects.filter(configuracion_id=config_id)
    texto = len(proveedores)
    datos = {'texto': texto, 'Proveedores' : proveedores,
             'envia': "Edwar C."}
    return redireccionar('inventario/proveedores.html', solicitud, datos)


@login_required
def proveedoresNuevo(solicitud):
    texto = ""
    proveedor = {}
    c = {}
    datos={}
    config_id = solicitud.session['config_id']
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        proveedor_id = solicitud.POST.get('proveedor_id')
        
        if proveedor_id != "0":
            proveedor = Proveedor.objects.filter(configuracion_id=config_id, id=proveedor_id)
            if len(proveedor)>0:
                proveedor = Proveedor.objects.get(configuracion_id=config_id, id=proveedor_id)
    datos = {'proveedor':proveedor, 'texto':texto}
    return redireccionar('inventario/proveedores_nuevo.html', solicitud, datos)


@login_required
def proveedoresGuardar(solicitud):
    texto = ""
    logo = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
           
        proveedor_id = solicitud.POST.get('proveedor-id')
        
        nit = solicitud.POST.get('proveedor-nit')
        nombre = solicitud.POST.get('proveedor-nombre')
        direccion = solicitud.POST.get('proveedor-direccion')
        telefono = solicitud.POST.get('proveedor-telefono')
        fax = solicitud.POST.get('proveedor-fax')
        email = solicitud.POST.get('proveedor-email')
        web = solicitud.POST.get('proveedor-web')
        
        for filename, file in solicitud.FILES.iteritems():
            logo = solicitud.FILES[filename].name
            logo = solicitud.FILES['proveedor-logo']
            
        es_laboratorio = solicitud.POST.get('chk-laboratorio', 0)
        if es_laboratorio!=0:
            es_laboratorio = 1
        observaciones = solicitud.POST.get('observaciones')
        
        if proveedor_id != "":
            proveedores = Proveedor.objects.filter(configuracion_id = config_id, id=proveedor_id)
            if len(proveedores)>0:
                proveedores = Proveedor.objects.get(configuracion_id = config_id, id=proveedor_id)
                proveedor_id = proveedores.id
            else:
                proveedor_id = ""
        if proveedor_id != "":
            proveedores = Proveedor.objects.get(configuracion_id = config_id, id=proveedor_id)
            proveedores.nit = nit
            proveedores.nombre = nombre
            proveedores.direccion = direccion
            proveedores.laboratorio = es_laboratorio
            proveedores.telefono = telefono
            proveedores.fax = fax
            proveedores.email = email
            proveedores.web = web
            proveedores.logo = logo
            proveedores.observaciones = observaciones
            proveedores.save()
        else:
            proveedores = Proveedor(configuracion_id = config_id, nit=nit, nombre=nombre, direccion=direccion, laboratorio=es_laboratorio,
                                  telefono=telefono, fax=fax, email=email, web=web, logo=logo, observaciones=observaciones)
            proveedores.save()
    else:
        texto = solicitud.method
    
    proveedores = Proveedor.objects.filter(configuracion_id=config_id)
    datos = {'texto': texto, 'Proveedores' : proveedores,
             'envia': "Edwar C."}
    return HttpResponseRedirect("/inventario/proveedores/")
#    return HttpResponse(texto)
#    return redireccionar('inventario/proveedores.html', solicitud, datos)

@login_required
def proveedoresBorrar(solicitud):
    texto = 0
    if solicitud.POST:
        texto = 0
        config_id = solicitud.session['config_id']
        proveedor_id = solicitud.POST.get('proveedor_id')
#        try:
        proveedores = Proveedor.objects.filter(configuracion_id=config_id, id=proveedor_id)
        for proveedor in proveedores:
            producto = Producto.objects.filter(laboratorio_id=proveedor.id)
            if len(producto)<1:
                tmp_proveedor = Proveedor.objects.get(id = proveedor.id)
                tmp_proveedor.delete()
                texto = 1
            else:
                texto = 0
                texto = "No se puede borrar el proveedor, está siendo usado por un producto."
    return HttpResponse(texto)


# ##########################################
# REPORTES
# ##########################################

@login_required
def reporteProductoProveedor(solicitud):
    datos={}
    user_sede = {}
    inv = []
    
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
        
    inventario = Inventario.objects.filter(configuracion_id=config_id).order_by("item__factura_compra__proveedor__nombre")
    
    for sede in user_sede:
        tmp_inventario = inventario.filter(sede_id = sede.sede_id)
        for tmp_inv in tmp_inventario:
            inv.append(tmp_inv)
    
    texto = len(inventario)
    datos = {'texto': texto, 'Inventario' : inv, 'user_sede' :user_sede,
             'envia': "Edwar C."}

    return redireccionar('inventario/reportes/producto_proveedor.html', solicitud, datos)


@login_required
def ConsumoProductos(solicitud):
    config_id = solicitud.session['config_id']
    configuracion = Configuracion.objects.get(id=config_id)
    datos = {'configuracion': configuracion}
    
    return redireccionar('inventario/reportes/consumo_productos.html', solicitud, datos)

@login_required
def ConsumoProductosReporte(solicitud):
#    inventario = inventarioResultadosConsulta(solicitud)
    config_id = solicitud.session['config_id']
    configuracion = Configuracion.objects.get(id=config_id)
    tmp_inicio = solicitud.POST.get('inicio', "")
    tmp_fin = solicitud.POST.get('fin', "")
    
    matriculas = {}
    categoria = 0
    inicio= ''
    fin = ''
    
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        configuracion = Configuracion.objects.get(id=config_id)
        
        texto = solicitud.POST.get('texto')
        tmp_inicio = solicitud.POST.get('inicio', "")
        tmp_fin = solicitud.POST.get('fin', "")
        
        if tmp_inicio != '':
            if int(tmp_inicio[6:10]) < 1000:
                anho =  2000 + int(tmp_inicio[6:10])
            else:
                anho = int(tmp_inicio[6:10])
            inicio = date(anho, int(tmp_inicio[3:5]), int(tmp_inicio[0:2]))
        
        
        if tmp_fin != '':
            if int(tmp_fin[6:10]) < 1000:
                anho =  2000 + int(tmp_fin[6:10])
            else:
                anho = int(tmp_fin[6:10])
            fin = date(anho, int(tmp_fin[3:5]), int(tmp_fin[0:2]))
        
        
        texto = ""
        inventario = FacturaVentaItem.objects.filter(configuracion_id=config_id)
        
        if inicio!='':
            texto = "%s %s" %(texto, "inicio")
            inventario = inventario.filter(factura_venta__fecha_emision__gte = inicio)
        if fin!='':
            texto = "%s %s" %(texto, "fin")
            inventario = inventario.filter(factura_venta__fecha_emision__lte = fin)
    else:
        texto = solicitud.method
        
    datos = {'Inventarios' : inventario, 'configuracion': configuracion, 'inicio':tmp_inicio, 'fin':tmp_fin}
    
    return redireccionar('inventario/reportes/consumo_productos_reporte.html', solicitud, datos)


@login_required
def informeSismed(solicitud):
    datos = informeSismedBuscar(solicitud)
    datos = {'Items' : datos}
    return redireccionar('inventario/reportes/informe_sismed.html', solicitud, datos)

def informeSismedBusca(solicitud):
    datos = informeSismedBuscar(solicitud)
    datos = {'Items' : datos}
    return redireccionar('inventario/reportes/informe_sismed_resultados.html', solicitud, datos)

def informeSismedBuscar(solicitud):
    datos={}
    texto = ""
    i=0
    config_id = solicitud.session['config_id']
    
    compra = FacturaCompra.objects.filter(configuracion_id=config_id)
    
    tmp_inicio = solicitud.POST.get('fecha-inicio', '')
    if tmp_inicio != '':
        inicio = date(int(tmp_inicio[6:10]), int(tmp_inicio[3:5]), int(tmp_inicio[0:2]))
        compra = compra.filter(fecha_emision__gte=inicio)
    else:
        fin = ""
        
    tmp_fin = solicitud.POST.get('fecha-fin', '')
    if tmp_fin != '':
        fin = date(int(tmp_fin[6:10]), int(tmp_fin[3:5]), int(tmp_fin[0:2]))
        compra = compra.filter(fecha_emision__lte=fin)
    else:
        fin=""
    
    categorias = Categoria.objects.filter(sismed=1)
    productos = Producto.objects.filter(configuracion_id=config_id, categoria__in=categorias)
    for producto in productos:
        valor_minimo = 0
        valor_maximo= 0
        cantidad = 0
        vlr_compra = 0
        f_min = 0
        f_max = 0
        items = FacturaCompraItem.objects.filter(configuracion_id=config_id, producto_id=producto.id, factura_compra__in=compra)
        for item in items:
            if item.valor_unitario<valor_minimo or valor_minimo==0:
                valor_minimo = item.valor_unitario
            if item.valor_unitario>valor_maximo:
                valor_maximo = item.valor_unitario
            if item.factura_compra.numero<f_max or f_min==0:
                f_min = item.factura_compra.numero
            if item.factura_compra.numero>f_max:
                f_max = item.factura_compra.numero
            
            cantidad = cantidad + item.cantidad
            vlr_compra=vlr_compra + (item.cantidad*item.valor_unitario)
            
            i=i+1
            datos[i] = {'Producto':producto, 'valor_minimo':valor_minimo, 'valor_maximo':valor_maximo, 'cantidad':cantidad, 
                                'valor_compra':vlr_compra, 'f_min':f_min, 'f_max':f_max, 'cons':i}
            
#    datos = {'texto': texto, 'Items' : datos}
    return datos

@login_required
def informeSismedExportar(solicitud):
    # Create the HttpResponse object with the appropriate CSV header.
    response = HttpResponse(mimetype='text/csv')
    response['Content-Type'] = 'text/csv; charset=utf-8'
    response['Content-Disposition'] = 'attachment; filename=reporte sismed.csv'
    response['charset'] = 'UTF-8'
    
    writer = csv.writer(response)
    writer.writerow(["CONS", "MEDICAMENTO","LABORATORIO", "COD. CUM", "COST. MIN",  
                         "COST. MAX", "VR. COMP", "CANT", "FACT MIN", "FACT MAX"])
    
    datos = informeSismedBuscar(solicitud)
    
    llaves = datos.keys()
    for indice in range(0,len(llaves)):
        writer.writerow([datos[llaves[indice]]["cons"], datos[llaves[indice]]["Producto"].nombre,
                         datos[llaves[indice]]["Producto"].laboratorio.nombre, datos[llaves[indice]]["Producto"].cum, 
                         datos[llaves[indice]]["valor_minimo"], datos[llaves[indice]]["valor_maximo"], 
                         datos[llaves[indice]]["cantidad"], datos[llaves[indice]]["valor_compra"], datos[llaves[indice]]["f_min"], datos[llaves[indice]]["f_max"],])
    
    return response


@login_required
def informeSismedReporte(solicitud):
    datos = informeSismedBuscar(solicitud)
    inicio = ""
    fin = ""
    tmp_inicio = solicitud.POST.get('fecha-inicio', '')
    if tmp_inicio != '':
        inicio = date(int(tmp_inicio[6:10]), int(tmp_inicio[3:5]), int(tmp_inicio[0:2]))
        
    tmp_fin = solicitud.POST.get('fecha-fin', '')
    if tmp_fin != '':
        fin = date(int(tmp_fin[6:10]), int(tmp_fin[3:5]), int(tmp_fin[0:2]))
        
    datos = {'Items' : datos, 'inicio':inicio, 'fin':fin}
    return redireccionar('inventario/reportes/reporte_sismed.html', solicitud, datos)

# ##########################################
# INVENTARIOS
# ##########################################

@login_required
def inventario(solicitud):
    datos={}
    user_sede = {}
    inv = []
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
        
    inventario = Inventario.objects.filter(configuracion_id=config_id)
    
    unidades = Unidad.objects.filter(configuracion_id=config_id)
    categorias = Categoria.objects.filter(configuracion_id=config_id)
    laboratorios = Proveedor.objects.filter(configuracion_id=config_id, laboratorio = 1)
    texto = len(inventario)
    datos = {'texto': texto, 'Inventario' : inv, 'Unidades' : unidades, 'user_sede' :user_sede,
             'Laboratorios' : laboratorios, 'Categorias' : categorias, 'envia': "Edwar C."}
    return redireccionar('inventario/inventario.html', solicitud, datos)


@login_required
def inventarioResultados(solicitud):
    inventario = inventarioResultadosConsulta(solicitud)
    datos = {'Inventarios' : inventario, 'envia': "Edwar C."}
    return redireccionar('inventario/inventario_resultados.html', solicitud, datos)
#    return HttpResponse(inventario)


@login_required
def inventarioReporte(solicitud):
    inventario = inventarioResultadosConsulta(solicitud)
    config_id = solicitud.session['config_id']
    configuracion = Configuracion.objects.get(id=config_id)
    sede = solicitud.POST.get('sede', '0')
    categoria = solicitud.POST.get('categoria', '0')
    tmp_inicio = solicitud.POST.get('inicio', "")
    tmp_fin = solicitud.POST.get('fin', "")
    datos = {'Inventarios' : inventario, 'configuracion': configuracion, 'sede':sede, 'categoria':categoria, 'inicio':tmp_inicio, 'fin':tmp_fin}
    return redireccionar('inventario/inventario_reporte.html', solicitud, datos)

@login_required
def inventarioResultadosConsulta(solicitud):
    matriculas = {}
    categoria = 0
    inicio= ''
    fin = ''
    
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        configuracion = Configuracion.objects.get(id=config_id)
        
        texto = solicitud.POST.get('texto')
        sede = solicitud.POST.get('sede', '0')
        categoria = solicitud.POST.get('categoria', '0')
        tmp_inicio = solicitud.POST.get('inicio', "")
        tmp_fin = solicitud.POST.get('fin', "")
        
        if tmp_inicio != '':
            if int(tmp_inicio[6:10]) < 1000:
                anho =  2000 + int(tmp_inicio[6:10])
            else:
                anho = int(tmp_inicio[6:10])
            inicio = date(anho, int(tmp_inicio[3:5]), int(tmp_inicio[0:2]))
        
        
        if tmp_fin != '':
            if int(tmp_fin[6:10]) < 1000:
                anho =  2000 + int(tmp_fin[6:10])
            else:
                anho = int(tmp_fin[6:10])
            fin = date(anho, int(tmp_fin[3:5]), int(tmp_fin[0:2]))
        
        
        texto = ""
        if sede != 0:
            inventario = Inventario.objects.filter(configuracion_id=config_id, sede_id = sede).order_by("sede", "item__producto__categoria", "item__producto")
        else:
            inventario = Inventario.objects.filter(configuracion_id=config_id).order_by("sede", "item__producto__categoria", "item__producto")
        if categoria != '0':
            texto = "%s %s %s"  %(texto, "categoria", categoria)
            inventario = inventario.filter(item__producto__categoria_id = categoria) 
        if inicio!='':
            texto = "%s %s" %(texto, "inicio")
            inventario = inventario.filter(item__factura_compra__fecha_emision__gte = inicio)
        if fin!='':
            texto = "%s %s" %(texto, "fin")
            inventario = inventario.filter(item__factura_compra__fecha_emision__lte = fin)
    else:
        texto = solicitud.method
    
    return inventario
#    return "sede: %s, inventario:%s, categoria:%s, inicio:%s, fin:%s, texto:%s " %(sede, len(inventario), categoria, inicio, fin, texto)


@login_required
def ConvertirOrdenFactura(solicitud):
    datos={}
    config_id = solicitud.session['config_id']
    facturas = OrdenFactura.objects.filter(configuracion_id=config_id)
    texto = len(facturas)
    datos = {'texto': texto, 'Ordenes' : facturas,
             'envia': "Edwar C."}
    return redireccionar('inventario/entradas/orden_factura.html', solicitud, datos)


@login_required
def ordenFacturaBorrar(solicitud):
    texto = ""
    datos = {}
    c = {}
    
    if solicitud.POST:
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        config_id = solicitud.session['config_id']
        try:
            factura_id = solicitud.POST.get('factura_id', "0")
            facturas = OrdenFactura.objects.filter(configuracion_id=config_id, id=factura_id)
            if len(facturas)>0:
                items = OrdenFacturaItem.objects.filter(configuracion_id=config_id, orden_factura_id=factura_id)
    #            texto = "Items: %s" %(len(items))
                if len(items)>0:
                    for item in items:
                        texto = OrdenFacturaBorrarItem(solicitud, item.id)
                facturas.delete()
                texto = 1
        except:
            texto = "Error borrando la factura."
    return HttpResponse(texto)

@login_required
def ConvertirOrdenFacturaNuevo(solicitud, factura_id="0"):
    datos={}
    texto = ""
    
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    ordenes = FacturaCompra.objects.filter(configuracion_id=config_id, movimiento_tipo_id=2)
    factura = {'subtotal':0, 'iva':0, 'total':0}
    items = {}
    if factura_id != "0":
        factura = OrdenFactura.objects.filter(configuracion_id=config_id, id = factura_id)
        if len(factura)>0:
            factura = OrdenFactura.objects.get(configuracion_id=config_id, id = factura_id)
            items = OrdenFacturaItem.objects.filter(orden_factura_id = factura_id)
        texto = factura_id
    else:
        texto = factura_id 
    datos = {'texto':texto, 'Factura':factura, 'Items':items, 'Ordenes':ordenes}
#    return datos
    return redireccionar('inventario/entradas/orden_factura_nuevo.html', solicitud, datos)


@login_required
def ConvertirOrdenFacturaItems(solicitud, factura_id="0"):
    datos={}
    texto = ""
    config_id = solicitud.session['config_id']
    orden_id = solicitud.POST.get('orden_id', '0')
    
    items = FacturaCompraItem.objects.filter(configuracion_id=config_id, factura_compra__movimiento_tipo_id=2, factura_compra_id=orden_id)
    datos = {'texto': texto, 'Items' : items, 'envia': "Edwar C."}
    return redireccionar('inventario/entradas/orden_factura_items.html', solicitud, datos)


@login_required
def ConvertirOrdenFacturaGuardar(solicitud):
    texto = OrdenFacturaGuardar(solicitud)
    return HttpResponseRedirect("/inventario/orden_factura/")
#    return HttpResponse(texto)

@login_required
def OrdenFacturaGuardar(solicitud):
    texto = ""
    entrada_id = 0
    proveedor = 0
    
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        session = Session.objects.get(session_key=solicitud.session.session_key)
        uid = session.get_decoded().get('_auth_user_id')
        user = User.objects.get(pk=uid)
        
        sede_id = solicitud.POST.get('sede')
        factura_id = solicitud.POST.get('orden-factura-id')   
        numero = solicitud.POST.get('factura-no')
        proveedor = solicitud.POST.get('proveedor-id', "")
        tmp_emision = solicitud.POST.get('emision', "")
        tmp_vencimiento = solicitud.POST.get('vencimiento', "")
        orden_id = solicitud.POST.get('orden-id')
        orden = solicitud.POST.get('orden-numero',"0")
        vendedor = solicitud.POST.get('vendedor')
        subtotal = solicitud.POST.get('subtotal', "0")
        iva = solicitud.POST.get('iva', "0")
        ajuste = solicitud.POST.get('vlr_ajuste', "0")
        retefuente = solicitud.POST.get('retefuente', "0")
        reteiva = solicitud.POST.get('reteiva', "0")
        transporte = solicitud.POST.get('transporte', "0")
        reteica = solicitud.POST.get('reteica', "0")
        retecre = solicitud.POST.get('retecre', "0")
        cuatroxmil = solicitud.POST.get('cuatroxmil', "0")
        descuento = solicitud.POST.get('descuento', "0")
        total = solicitud.POST.get('total', "0")
        pagada = solicitud.POST.get('chk-pagada', 0)
        observaciones = solicitud.POST.get('observaciones')
        subtotal = subtotal.replace(u",", ".")
        iva = iva.replace(u",", ".")
        total = total.replace(u",", ".")
        ajuste = ajuste.replace(u",", ".")
        retefuente = retefuente.replace(u".", "")
        retefuente = retefuente.replace(u",", ".")
        reteiva = reteiva.replace(u".", "")
        reteiva = reteiva.replace(u",", ".")
        transporte = transporte.replace(u".", "")
        transporte = transporte.replace(u",", ".")
        reteica = reteica.replace(u".", "")
        reteica = reteica.replace(u",", ".")
        retecre = retecre.replace(u".", "")
        retecre = retecre.replace(u",", ".")
        cuatroxmil = cuatroxmil.replace(u".", "")
        cuatroxmil = cuatroxmil.replace(u",", ".")
        descuento = descuento.replace(u".", "")
        descuento = descuento.replace(u",", ".")
        
        if len(ajuste)<1:
            ajuste = 0
            
        if len(retefuente)<1:
            retefuente = 0
            
        if len(reteiva)<1:
            reteiva = 0
        
        if len(transporte)<1:
            transporte = 0
        
        if len(reteica)<1:
            reteica = 0
        
        if len(retecre)<1:
            retecre = 0
            
        if len(cuatroxmil)<1:
            cuatroxmil = 0
            
        if len(descuento)<1:
            descuento = 0
        
        if pagada!=0:
            pagada = 1
        
        texto = "Pagada: %s" %(pagada)
        if tmp_emision != '':
            if int(tmp_emision[6:10]) < 1000:
                anho =  2000 + int(tmp_emision[6:10])
            else:
                anho = int(tmp_emision[6:10])
            emision = date(anho, int(tmp_emision[3:5]), int(tmp_emision[0:2]))
        else:
            emision = date.today()
            
        if tmp_vencimiento != '':
            if int(tmp_vencimiento[6:10]) < 1000:
                anho =  2000 + int(tmp_vencimiento[6:10])
            else:
                anho = int(tmp_vencimiento[6:10])
            vencimiento = date(anho, int(tmp_vencimiento[3:5]), int(tmp_vencimiento[0:2]))
        else:
            vencimiento = date.today()
            
        
        if factura_id != "":
            factura = OrdenFactura.objects.filter(configuracion_id = config_id, id = factura_id)
            if len(factura)>0:
                factura = OrdenFactura.objects.get(configuracion_id = config_id, id = factura_id)
                factura_id = factura.id
            else:
                factura_id = ""
        
        if factura_id == "":
            factura = OrdenFactura(configuracion_id=config_id, sede_id = sede_id, numero=numero, proveedor_id=proveedor, fecha_emision=emision, fecha_vencimiento=vencimiento,
                          orden_numero=orden, orden_compra_id=orden_id, vendedor=vendedor, subtotal=subtotal, iva=iva, ajuste_peso=ajuste, retefuente=retefuente, reteiva=reteiva, transporte=transporte, reteica=reteica, 
                           retecre=retecre,  cuatroxmil=cuatroxmil, descuento=descuento, total=total, pagada=pagada, observaciones=observaciones)
        else:
            factura = OrdenFactura.objects.get(configuracion_id = config_id, id = factura_id)
            factura.numero = numero
            factura.proveedor_id = proveedor
            factura.sede_id = sede_id
            factura.fecha_emision = emision
            factura.fecha_vencimiento = vencimiento
            factura.orden_numero = orden
            factura.orden_compra_id = orden_id
            factura.vendedor = vendedor
            factura.subtotal = subtotal
            factura.iva = iva
            factura.ajuste_peso = ajuste
            factura.retefuente = retefuente
            factura.reteiva = reteiva
            factura.transporte = transporte
            factura.reteica = reteica
            factura.retecre = retecre
            factura.cuatroxmil = cuatroxmil
            factura.descuento = descuento
            factura.total = total
            factura.pagada = pagada
            factura.observaciones = observaciones
        
        factura.save()
        entrada_id = factura.id
        
#        movimientos = Movimientos.objects.filter(configuracion_id=config_id, tipo_movimiento_id=movimiento_tipo, responsable_id=uid, id_documento=factura.id)
#        observacion = len(movimientos)
#        if len(movimientos)<=0:
#            movimiento = Movimientos(configuracion_id=config_id, tipo_movimiento_id=movimiento_tipo, fecha=date.today(), responsable_id=uid, id_documento=factura.id, observaciones=observacion)
#            movimiento.save()
            
        campos = solicitud.POST.get('cant_campos','0')
        
        
        i=0
        no_existe = 0
        while i<int(campos):
            texto = "%s while: %s <br/>" %(texto, i)
            i=i+1
            att = "hdnProducto_%s" %(i)
            for atributo, file in solicitud.POST.iteritems():
                if atributo == att:
                    texto = "%s att: %s == atributo: %s <br/>" %(texto, att, atributo)
                    
                    producto = solicitud.POST.get(att, "")
                    att = "hdnItem_%s" %(i)
                    item_id = solicitud.POST.get(att, "")
                    att = "hdnCantidad_%s" %(i)
                    cantidad = solicitud.POST.get(att, "0")
                    att = "hdnLote_%s" %(i)
                    lote = solicitud.POST.get(att, "")
                    att = "hdnVencimiento_%s" %(i)
                    tmp_vencimiento = solicitud.POST.get(att, "")
                    if tmp_vencimiento != '':
                        if tmp_vencimiento != '':
                            if int(tmp_vencimiento[6:10]) < 1000:
                                anho =  2000 + int(tmp_vencimiento[6:10])
                            else:
                                anho = int(tmp_vencimiento[6:10])
                        vencimiento = date(anho, int(tmp_vencimiento[3:5]), int(tmp_vencimiento[0:2]))
                    else:
                        vencimiento = date.today()
                    
                    att = "hdnUnitario_%s" %(i)
                    unitario = solicitud.POST.get(att, "0")
                    unitario = unitario.replace(u",", ".")
                    att = "hdnIva_%s" %(i)
                    iva = solicitud.POST.get(att, "0")
                    iva = iva.replace(u",", ".")
                    att = "hdnVenta_%s" %(i)
                    venta = solicitud.POST.get(att, "0")
                    venta = venta.replace(u",", ".")
                    att = ""
                    texto = "%s item_id: %s  <br/>" %(texto, item_id)
                    
                    factura_item = OrdenFacturaItem.objects.filter(configuracion_id = config_id, orden_factura_id=factura.id, id = item_id)
                    if len(factura_item)<=0:
                        texto = "%s i: %s  ---- *** Guardando Producto: %s...<br/>" %(texto, i, producto)
                        facturaItem = OrdenFacturaItem(configuracion_id = config_id, orden_factura_id=factura.id, item_id=item_id, cantidad=cantidad)
                        facturaItem.save()
                    else:
                        factura_item = OrdenFacturaItem.objects.get(configuracion_id = config_id, orden_factura_id=factura.id, id = item_id)
                        factura_item.cantidad = cantidad
                        factura_item.save()
                            
                else:
                    no_existe = no_existe+1
        
        
#        GUARDAR EL SUBTOTAL, IVA Y TOTAL DE FACTURA EN FUNCIÓN DE LOS ITEMS DE FACTURA
        t_compra = 0
        t_iva  = 0
        t_total = 0
        
#        texto = " CALCULANDO LA FACTURA DE COMPRA %s" %(factura.id)
        compras = OrdenFacturaItem.objects.filter(orden_factura_id=factura.id)
        for compra in compras:
            t_compra = t_compra +  (compra.item.valor_unitario * compra.cantidad)
            t_iva  = t_iva + (compra.item.iva * compra.cantidad)
        
        t_total = t_compra + t_iva
        
        factura.subtotal = t_compra
        factura.iva = t_iva
        factura.total = t_total + float(ajuste) + float(retefuente) + float(reteiva) + float(transporte) - float(descuento) + float(reteica) + float(retecre) + float(cuatroxmil)
        factura.save()
        entrada_id = factura.id
    else:
        texto = solicitud.method
    
    facturas = OrdenFactura.objects.filter(configuracion_id=config_id)
    datos = {'texto': texto, 'Facturas' : facturas, 'envia': "Edwar C.", "entrada_id":entrada_id}
#    return texto
    return datos

@login_required
def ConvertirOrdenFacturaBorrar(solicitud):
    texto = entradasBorrar(solicitud)
    return HttpResponse(texto)


@login_required
def ConvertirOrdenFacturaBorrarItem(solicitud):
    texto = 0
    if solicitud.POST:
        item_id = solicitud.POST.get('item')
        texto = OrdenFacturaBorrarItem(solicitud, item_id)
    return HttpResponse(texto)


@login_required
def OrdenFacturaBorrarItem(solicitud, item_id):
    texto = 0
    config_id = solicitud.session['config_id']
        
    if solicitud.POST:
        item_id = solicitud.POST.get('item', "0")
        orden_factura_id = solicitud.POST.get('orden_factura_id', "0")
        if len(orden_factura_id)>0:
            Items = OrdenFacturaItem.objects.filter(configuracion_id=config_id, id=orden_factura_id, item_id=item_id)
            if len(Items)>0:
                Item = OrdenFacturaItem.objects.get(configuracion_id=config_id, orden_factura_id=orden_factura_id, item_id=item_id)
                Item.delete()
                texto = 1
            else:
                texto = 2
        else:
            texto = 2
    return texto

# ##########################################
# INVENTARIOS
# ##########################################
    
@login_required
def traslados(solicitud):
    datos={}
    config_id = solicitud.session['config_id']
    traslados = Traslado.objects.filter(configuracion_id=config_id)
    texto = len(traslados)
    datos = {'texto': texto, 'Traslados' : traslados, 'envia': "Edwar C."}
    return redireccionar('inventario/traslados.html', solicitud, datos)


@login_required
def trasladosNuevo(solicitud):
    texto = ""
    traslado = {}
    c = {}
    datos={}
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
    
    sede = Sede.objects.filter(configuracion_id=config_id)
    
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        traslado_id = solicitud.POST.get('traslado_id')
        
        if traslado_id != "0":
            traslado = Traslado.objects.filter(configuracion_id=config_id, id=traslado_id)
            if len(traslado)>0:
                traslado = Traslado.objects.get(configuracion_id=config_id, id=traslado_id)
    datos = {'traslado':traslado, 'texto':texto, 'user_sede':user_sede, 'Sedes':sede}
    texto = "%s, %s " %(traslado_id, config_id) 
    return redireccionar('inventario/traslados_nuevo.html', solicitud, datos)
#    return HttpResponse(texto)


@login_required
def trasladosGuardar(solicitud):
    texto = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        session = Session.objects.get(session_key=solicitud.session.session_key)
        uid = session.get_decoded().get('_auth_user_id')
    
        traslado_id = solicitud.POST.get('traslado-id')
        
        tmp_fecha = solicitud.POST.get('fecha')
        sede_origen = solicitud.POST.get('sede-origen')
        sede_destino = solicitud.POST.get('sede-destino')
        producto = solicitud.POST.get('producto-id')
        cantidad = solicitud.POST.get('cantidad')
        
        if tmp_fecha != '':
            if int(tmp_fecha[6:10]) < 1000:
                anho =  2000 + int(tmp_fecha[6:10])
            else:
                anho = int(tmp_fecha[6:10])
            fecha = date(anho, int(tmp_fecha[3:5]), int(tmp_fecha[0:2]))
        else:
            fecha = date.today()
                            
        if traslado_id != "":
            traslados = Traslado.objects.filter(configuracion_id = config_id, id=traslado_id)
            if len(traslados)>0:
                traslados = Traslado.objects.get(configuracion_id = config_id, id=traslado_id)
                traslado_id = traslados.id
            else:
                traslado_id = ""
                
        if traslado_id != "":
            traslados = Traslado.objects.get(configuracion_id = config_id, id=traslado_id)
            traslados.fecha = fecha
            traslados.sede_origen_id = sede_origen
            traslados.sede_destino_id = sede_destino
            traslados.producto_id = producto
            traslados.cantidad = cantidad
            traslados.responsable_id = uid
            traslados.save()
            movimientos = Movimientos.objects.filter(configuracion_id=config_id, tipo_movimiento_id=20, responsable_id=uid, id_documento=traslados.id)
            if len(movimientos)<=0:
                movimiento = Movimientos(configuracion_id=config_id, tipo_movimiento_id=20, responsable_id=uid, id_documento=traslados.id)
                movimiento.save()
        else:
            traslados = Traslado(configuracion_id = config_id, fecha=fecha, sede_origen_id=sede_origen, sede_destino_id=sede_destino, 
                                  producto_id=producto, cantidad=cantidad, responsable_id=uid)
            traslados.save()
            
            movimientos = Movimientos.objects.filter(configuracion_id=config_id, tipo_movimiento_id=20, responsable_id=uid, id_documento=traslados.id)
            if len(movimientos)<=0:
                movimiento = Movimientos(configuracion_id=config_id, tipo_movimiento_id=20, responsable_id=uid, id_documento=traslados.id)
                movimiento.save()
    else:
        texto = solicitud.method
    
    
    traslados = Traslado.objects.filter(configuracion_id=config_id)
    datos = {'texto': texto, 'Traslados' : traslados, 'envia': "Edwar C."}
    return HttpResponseRedirect("/inventario/traslados/")


@login_required
def trasladosBorrar(solicitud):
    texto = 0
    if solicitud.POST:
        texto = 0
        config_id = solicitud.session['config_id']
        traslados_id = solicitud.POST.get('traslados_id', 0)
#        try:
        traslados = Traslado.objects.filter(configuracion_id=config_id, id=traslados_id)
        for traslado in traslados:
            traslado.delete()
            texto = 1
            
    return HttpResponse(texto)
#    return HttpResponseRedirect("/inventario/traslados/")


# ##########################################
# PRODUCTOS
# ##########################################

@login_required
def productos(solicitud, texto=""):
    datos={}
    config_id = solicitud.session['config_id']
    productos = Producto.objects.filter(configuracion_id=config_id)
    texto = len(productos)
    datos = {'texto': texto, 'Productos' : productos, 'envia': "Edwar C."}
    return redireccionar('inventario/productos.html', solicitud, datos)


@login_required
def productosNuevo(solicitud, texto=""):
    datos={}
    c = {}
    producto = {}
    config_id = solicitud.session['config_id']
#    datos = productos(solicitud, texto)
    productos = Producto.objects.filter(configuracion_id=config_id)
    unidades = Unidad.objects.filter(configuracion_id=config_id)
    categorias = Categoria.objects.filter(configuracion_id=config_id)
    laboratorios = Proveedor.objects.filter(configuracion_id=config_id, laboratorio = 1)
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        producto_id = solicitud.POST.get('producto_id')
        
        if producto_id != "0":
            producto = Producto.objects.filter(configuracion_id=config_id, id=producto_id)
            if len(producto)>0:
                producto = Producto.objects.get(configuracion_id=config_id, id=producto_id)
                texto = producto.nombre
        
    datos = {'texto': texto, 'Productos' : productos, 'Unidades' : unidades, 'Categorias' : categorias, 
                'Laboratorios' : laboratorios, 'producto' : producto, 'envia': "Edwar C."}
    return redireccionar('inventario/productos_nuevo.html', solicitud, datos)


@login_required
def productosGuardar(solicitud):
    texto = ""
    logo = ""
    
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
           
        cum = solicitud.POST.get('cum')
        codigo = solicitud.POST.get('codigo')
        producto_id = solicitud.POST.get('id')
        nombre = solicitud.POST.get('nombre')
        laboratorio = solicitud.POST.get('laboratorio')
        categoria = solicitud.POST.get('categoria')
        unidad = solicitud.POST.get('unidad')
        invima = solicitud.POST.get('invima')
        descripcion = solicitud.POST.get('descripcion')
        observaciones = solicitud.POST.get('observaciones')
        
        for filename, file in solicitud.FILES.iteritems():
            logo = solicitud.FILES[filename].name
            logo = solicitud.FILES['logo']
        
        
        if producto_id != "":
            productos = Producto.objects.filter(configuracion_id = config_id, id=producto_id)
            if len(productos)>0:
                productos = Producto.objects.get(configuracion_id = config_id, id=producto_id)
                producto_id = productos.id
            else:
                producto_id = ""
        
        if producto_id != "":
            producto = Producto.objects.get(configuracion_id = config_id, id=producto_id)
            producto.cum = cum
            producto.codigo = codigo
            producto.nombre = nombre
            producto.laboratorio_id = laboratorio
            producto.categoria_id = categoria
            producto.unidad_id = unidad
            producto.invima = invima
            producto.descripcion = descripcion
            producto.logo = logo
            producto.observaciones = observaciones
            producto.save()
        else:
            producto = Producto(configuracion_id = config_id, cum=cum, codigo=codigo, nombre=nombre, laboratorio_id=laboratorio, categoria_id=categoria,
                                      unidad_id=unidad, invima=invima, descripcion=descripcion, logo=logo, observaciones=observaciones)
            producto.save()
    else:
        texto = solicitud.method
    
    productos = Producto.objects.filter(configuracion_id=config_id)
    datos = {'texto': texto, 'Productos' : productos, 'envia': "Edwar C."}
    return HttpResponseRedirect("/inventario/productos/")

@login_required
def productosBorrar(solicitud):
    texto = 0
    if solicitud.POST:
        texto = 0
        config_id = solicitud.session['config_id']
        producto_id = solicitud.POST.get('producto_id', 0)
#        try:
        productos = Producto.objects.filter(configuracion_id=config_id, id=producto_id)
        if len(productos)>0:
            compra = FacturaCompraItem.objects.filter(configuracion_id=config_id, producto_id=producto_id)
            if len(compra)<1:
                tmp_producto = Producto.objects.get(id = producto_id)
                tmp_producto.delete()
                texto = 1
            else:
                texto = 0
    return HttpResponse(texto)


##########################
# MÓDULOS DE FACTURAS DE COMPRA
##########################

@login_required
def reintegroBuscar(solicitud):
    datos={}
    config_id = solicitud.session['config_id']
    facturas = Reintegro.objects.filter(configuracion_id=config_id)
    texto = len(facturas)
    datos = {'texto': texto, 'Reintegros' : facturas}
    return redireccionar('inventario/entradas/reintegro.html', solicitud, datos)


@login_required
def reintegroNuevo(solicitud, reintegro_id="0"):
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    prestamos = FacturaVenta.objects.filter(configuracion_id=config_id, movimiento_tipo_id=14, pagada=0)
    reintegro = {}
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
    
    items = {}
    if reintegro_id != "0":
        reintegros = Reintegro.objects.filter(configuracion_id=config_id, id = reintegro_id)
        if len(reintegros)>0:
            reintegro = Reintegro.objects.get(configuracion_id=config_id, id = reintegro_id)
            items = FacturaCompraItem.objects.filter(factura_compra_id = reintegro.factura_compra_id)
        texto = reintegro_id
    else:
        texto = reintegro_id 
    datos = {'Sedes':user_sede, 'texto':texto, 'Prestamos':prestamos,
             'Reintegro':reintegro, 'Items':items}
#    return HttpResponse(items)
    return redireccionar('inventario/entradas/reintegro_nuevo.html', solicitud, datos)

@login_required
def reintegroGuardar(solicitud):
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    if solicitud.method == 'POST':
        datos = entradasGuardar(solicitud, 3)
        config_id = solicitud.session['config_id']
        reintegro_id = solicitud.POST.get('reintegro-id')
        prestamo_id = solicitud.POST.get('prestamo-id', "0")
        tmp_emision = solicitud.POST.get('emision', "")
        pagada = solicitud.POST.get('chk-pagada', 0)
        
        if tmp_emision != '':
            if int(tmp_emision[6:10]) < 1000:
                anho =  2000 + int(tmp_emision[6:10])
            else:
                anho = int(tmp_emision[6:10])
            emision = date(anho, int(tmp_emision[3:5]), int(tmp_emision[0:2]))
        else:
            emision = date.today()
            
        if pagada!=0:
            pagada = 1
        
        if prestamo_id != "0":
            venta = FacturaVenta.objects.filter(configuracion_id=config_id, id=prestamo_id)
            if len(venta)>0:
                venta = FacturaVenta.objects.get(configuracion_id=config_id, id=prestamo_id)
                venta.pagada = pagada
                venta.save()
                
        factura_id = datos['entrada_id']
        if reintegro_id == "":
            reintegro = Reintegro(configuracion_id=config_id, fecha=emision, factura_compra_id=factura_id, factura_venta_id=prestamo_id)
        else:
            reintegro = Reintegro.objects.get(configuracion_id = config_id, id = reintegro_id)
            reintegro.fecha = emision
            reintegro.factura_compra_id = factura_id
            reintegro.factura_venta_id = prestamo_id
                
        reintegro.save()
        reintegro_id = reintegro.id
        
        movimientos = Movimientos.objects.filter(configuracion_id=config_id, tipo_movimiento_id=3, responsable_id=uid, id_documento=reintegro.id)
        observacion = len(movimientos)
        if len(movimientos)<=0:
            movimiento = Movimientos(configuracion_id=config_id, tipo_movimiento_id=3, fecha=date.today(), responsable_id=uid, id_documento=reintegro.id, observaciones=observacion)
            movimiento.save()
       
#    return HttpResponse(pagada)
    return HttpResponseRedirect("/inventario/reintegro/")


@login_required
def reintegroBorrar(solicitud):
    texto = 0
    datos = {}
    if solicitud.POST:
        texto = 0
        reintegro_id = solicitud.POST.get('reintegro_id', 0)
        config_id = solicitud.session['config_id']
#        try:
        reintegros = Reintegro.objects.filter(configuracion_id=config_id, id=reintegro_id)
        for reintegro in reintegros:
            factura=FacturaCompra.objects.filter(configuracion_id=config_id, id=reintegro.factura_compra_id)
            if len(factura)>0:
                factura=FacturaCompra.objects.get(configuracion_id=config_id, id=reintegro.factura_compra_id)
                items = FacturaCompraItem.objects.filter(configuracion_id=config_id, factura_compra_id=factura.id)
                for item in items:
                    item.delete()
                factura.delete()
            reintegro.delete()
            
            venta = FacturaVenta.objects.get(configuracion_id=config_id, id=reintegro.factura_venta_id)
            venta.pagada = 0
            venta.save()
            
            texto = 1
    return HttpResponse(texto)
#    texto = entradasBorrar(solicitud)
#    return HttpResponseRedirect("/inventario/reintegro/")



@login_required
def ordenEntradaBuscar(solicitud):
    datos={}
    config_id = solicitud.session['config_id']
    facturas = FacturaCompra.objects.filter(configuracion_id=config_id, movimiento_tipo_id=2)
    texto = len(facturas)
    datos = {'texto': texto, 'Ordenes' : facturas,
             'envia': "Edwar C."}
    return redireccionar('inventario/entradas/orden_entrada.html', solicitud, datos)


@login_required
def ordenEntradaNuevo(solicitud, factura_id="0"):
    datos=facturasCompra(solicitud, factura_id)
    return redireccionar('inventario/entradas/orden_entrada_nuevo.html', solicitud, datos)

@login_required
def ordenEntradaGuardar(solicitud):
    texto = entradasGuardar(solicitud, 2)
    return HttpResponseRedirect("/inventario/orden_entrada/")


@login_required
def ordenEntradaBorrar(solicitud):
    texto = entradasBorrar(solicitud)
    return HttpResponse(texto)
#    texto = entradasBorrar(solicitud)
#    return HttpResponseRedirect("/inventario/orden_entrada/")


@login_required
def facturasCompraBuscar(solicitud):
    datos={}
    config_id = solicitud.session['config_id']
    facturas = FacturaCompra.objects.filter(configuracion_id=config_id, movimiento_tipo_id=1)
    texto = len(facturas)
    datos = {'texto': texto, 'Facturas' : facturas, 'envia': "Edwar C."}
    return redireccionar('inventario/entradas/facturas_compra.html', solicitud, datos)


@login_required
def facturasCompraBorrar(solicitud):
    texto = entradasBorrar(solicitud)
    return HttpResponse(texto)
#    return HttpResponseRedirect("/inventario/facturas_compra/")


@login_required
def facturasCompra(solicitud, factura_id="0", movimiento_tipo=0):
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
    
    Proveedores = Proveedor.objects.filter(configuracion_id=config_id)
    Productos = Producto.objects.filter(configuracion_id=config_id)
    factura = {'subtotal':0, 'iva':0, 'total':0}
    items = {}
    if factura_id != "0":
        factura = FacturaCompra.objects.filter(configuracion_id=config_id, id = factura_id)
        if len(factura)>0:
            factura = FacturaCompra.objects.get(configuracion_id=config_id, id = factura_id)
            items = FacturaCompraItem.objects.filter(factura_compra_id = factura_id)
        texto = factura_id
    else:
        texto = factura_id 
    datos = {'Proveedores': Proveedores, 'Sedes':user_sede, 'Productos':Productos, 'texto':texto,
             'Factura':factura, 'Items':items, 'tipo_movimiento': movimiento_tipo}
    return datos
    

@login_required
def facturasCompraNuevo(solicitud, factura_id="0"):
    datos=facturasCompra(solicitud, factura_id)
    return redireccionar('inventario/entradas/facturas_compra_nuevo.html', solicitud, datos)


@login_required
def facturasCompraGuardar(solicitud):
    texto = entradasGuardar(solicitud, 1)
    return HttpResponseRedirect("/inventario/facturas_compra/")
    

@login_required
def bsqProducto(solicitud):
    texto = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        bsq_producto = solicitud.POST.get('producto')
        Productos = Producto.objects.filter(configuracion_id=config_id, nombre__icontains=bsq_producto)
        for (i,producto) in enumerate(Productos):
            texto = "%s <a href=\"#\" id=\"resp%s\" value=\"%s\" onClick=\"copyToBox($('#resp%s'))\">%s</a><br/>" %(texto, i, producto.id, i, producto.nombre)
    return HttpResponse(texto)


@login_required
def bsqProveedor(solicitud):
    texto = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        bsq_proveedor = solicitud.POST.get('proveedor')
        Proveedores = Proveedor.objects.filter(configuracion_id=config_id, nombre__icontains=bsq_proveedor)
        for (i,proveedor) in enumerate(Proveedores):
            texto = "%s <a href=\"#\" id=\"res%s\" value=\"%s\" onClick=\"copyToProveedor($('#res%s'))\">%s</a><br/>" %(texto, i, proveedor.id, i, proveedor.nombre)
    return HttpResponse(texto)


@login_required
def entradasGuardar(solicitud, movimiento_tipo):
    texto = ""
    entrada_id = 0
    proveedor = 0
    
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        session = Session.objects.get(session_key=solicitud.session.session_key)
        uid = session.get_decoded().get('_auth_user_id')
        user = User.objects.get(pk=uid)
        
        sede_id = solicitud.POST.get('sede')
        factura_id = solicitud.POST.get('factura-id')   
        numero = solicitud.POST.get('factura-no')
        proveedor = solicitud.POST.get('proveedor-id', "")
        tmp_emision = solicitud.POST.get('emision', "")
        tmp_vencimiento = solicitud.POST.get('vencimiento', "")
        orden = solicitud.POST.get('orden-compra')
        vendedor = solicitud.POST.get('vendedor')
        subtotal = solicitud.POST.get('subtotal', "0")
        iva = solicitud.POST.get('iva', "0")
        ajuste = solicitud.POST.get('vlr_ajuste', "0")
        retefuente = solicitud.POST.get('retefuente', "0")
        reteiva = solicitud.POST.get('reteiva', "0")
        transporte = solicitud.POST.get('transporte', "0")
        reteica = solicitud.POST.get('reteica', "0")
        retecre = solicitud.POST.get('retecre', "0")
        cuatroxmil = solicitud.POST.get('cuatroxmil', "0")
        descuento = solicitud.POST.get('descuento', "0")
        total = solicitud.POST.get('total', "0")
        pagada = solicitud.POST.get('chk-pagada', 0)
        observaciones = solicitud.POST.get('observaciones')
        subtotal = subtotal.replace(u",", ".")
        iva = iva.replace(u",", ".")
        total = total.replace(u",", ".")
        ajuste = ajuste.replace(u",", ".")
        retefuente = retefuente.replace(u".", "")
        retefuente = retefuente.replace(u",", ".")
        reteiva = reteiva.replace(u".", "")
        reteiva = reteiva.replace(u",", ".")
        transporte = transporte.replace(u".", "")
        transporte = transporte.replace(u",", ".")
        reteica = reteica.replace(u".", "")
        reteica = reteica.replace(u",", ".")
        retecre = retecre.replace(u".", "")
        retecre = retecre.replace(u",", ".")
        cuatroxmil = cuatroxmil.replace(u".", "")
        cuatroxmil = cuatroxmil.replace(u",", ".")
        descuento = descuento.replace(u".", "")
        descuento = descuento.replace(u",", ".")
        
        if len(ajuste)<1:
            ajuste = 0
            
        if len(retefuente)<1:
            retefuente = 0
            
        if len(reteiva)<1:
            reteiva = 0
        
        if len(transporte)<1:
            transporte = 0
        
        if len(reteica)<1:
            reteica = 0
        
        if len(retecre)<1:
            retecre = 0
            
        if len(cuatroxmil)<1:
            cuatroxmil = 0
            
        if len(descuento)<1:
            descuento = 0
        
        if pagada!=0:
            pagada = 1
        
        texto = "Pagada: %s" %(pagada)
        if tmp_emision != '':
            if int(tmp_emision[6:10]) < 1000:
                anho =  2000 + int(tmp_emision[6:10])
            else:
                anho = int(tmp_emision[6:10])
            emision = date(anho, int(tmp_emision[3:5]), int(tmp_emision[0:2]))
        else:
            emision = date.today()
            
        if tmp_vencimiento != '':
            if int(tmp_vencimiento[6:10]) < 1000:
                anho =  2000 + int(tmp_vencimiento[6:10])
            else:
                anho = int(tmp_vencimiento[6:10])
            vencimiento = date(anho, int(tmp_vencimiento[3:5]), int(tmp_vencimiento[0:2]))
        else:
            vencimiento = date.today()
            
        
        if factura_id != "":
            factura = FacturaCompra.objects.filter(configuracion_id = config_id, id = factura_id)
            if len(factura)>0:
                factura = FacturaCompra.objects.get(configuracion_id = config_id, id = factura_id)
                factura_id = factura.id
            else:
                factura_id = ""
        
        if factura_id == "":
            factura = FacturaCompra(configuracion_id=config_id, movimiento_tipo_id=movimiento_tipo, sede_id = sede_id, numero=numero, proveedor_id=proveedor, fecha_emision=emision, fecha_vencimiento=vencimiento,
                              orden_compra=orden, vendedor=vendedor, subtotal=subtotal, iva=iva, ajuste_peso=ajuste, retefuente=retefuente, reteiva=reteiva, transporte=transporte, reteica=reteica, 
                               retecre=retecre,  cuatroxmil=cuatroxmil, descuento=descuento, total=total, pagada=pagada, observaciones=observaciones)
        else:
            factura = FacturaCompra.objects.get(configuracion_id = config_id, id = factura_id)
            factura.numero = numero
            factura.proveedor_id = proveedor
            factura.sede_id = sede_id
            factura.fecha_emision = emision
            factura.fecha_vencimiento = vencimiento
            factura.orden_compra = orden
            factura.vendedor = vendedor
            factura.subtotal = subtotal
            factura.iva = iva
            factura.ajuste_peso = ajuste
            factura.retefuente = retefuente
            factura.reteiva = reteiva
            factura.transporte = transporte
            factura.reteica = reteica
            factura.retecre = retecre
            factura.cuatroxmil = cuatroxmil
            factura.descuento = descuento
            factura.total = total
            factura.pagada = pagada
            factura.observaciones = observaciones
        
        factura.save()
        entrada_id = factura.id
        
        movimientos = Movimientos.objects.filter(configuracion_id=config_id, tipo_movimiento_id=movimiento_tipo, responsable_id=uid, id_documento=factura.id)
        observacion = len(movimientos)
        if len(movimientos)<=0:
            movimiento = Movimientos(configuracion_id=config_id, tipo_movimiento_id=movimiento_tipo, fecha=date.today(), responsable_id=uid, id_documento=factura.id, observaciones=observacion)
            movimiento.save()
            
        campos = solicitud.POST.get('cant_campos')
        
        
        i=0
        no_existe = 0
        while i<int(campos):
            i=i+1
            att = "hdnProducto_%s" %(i)
            for atributo, file in solicitud.POST.iteritems():
                if atributo == att:
                    texto = "%s att: %s == atributo: %s <br/>" %(texto, att, atributo)
                    
                    producto = solicitud.POST.get(att, "")
                    att = "hdnItem_%s" %(i)
                    item_id = solicitud.POST.get(att, "")
                    att = "hdnCantidad_%s" %(i)
                    cantidad = solicitud.POST.get(att, "0")
                    att = "hdnLote_%s" %(i)
                    lote = solicitud.POST.get(att, "")
                    att = "hdnVencimiento_%s" %(i)
                    tmp_vencimiento = solicitud.POST.get(att, "")
                    if tmp_vencimiento != '':
                        if tmp_vencimiento != '':
                            if int(tmp_vencimiento[6:10]) < 1000:
                                anho =  2000 + int(tmp_vencimiento[6:10])
                            else:
                                anho = int(tmp_vencimiento[6:10])
                        vencimiento = date(anho, int(tmp_vencimiento[3:5]), int(tmp_vencimiento[0:2]))
                    else:
                        vencimiento = date.today()
                    
                    att = "hdnUnitario_%s" %(i)
                    unitario = solicitud.POST.get(att, "0")
                    unitario = unitario.replace(u",", ".")
                    att = "hdnIva_%s" %(i)
                    iva = solicitud.POST.get(att, "0")
                    iva = iva.replace(u",", ".")
                    att = "hdnVenta_%s" %(i)
                    venta = solicitud.POST.get(att, "0")
                    venta = venta.replace(u",", ".")
                    att = ""
                    if item_id == "0":
                        texto = "%s i: %s  ---- *** Guardando Producto: %s...<br/>" %(texto, i, producto)
                        facturaItem = FacturaCompraItem(configuracion_id = config_id, factura_compra_id=factura.id, producto_id=producto, cantidad=cantidad, 
                                                lote=lote, fecha_vencimiento=vencimiento, valor_unitario=unitario, iva=iva, valor_venta = venta)
                        facturaItem.save()
                    
                else:
                    no_existe = no_existe+1
        
        
#        GUARDAR EL SUBTOTAL, IVA Y TOTAL DE FACTURA EN FUNCIÓN DE LOS ITEMS DE FACTURA
        t_compra = 0
        t_iva  = 0
        t_total = 0
        
#        texto = " CALCULANDO LA FACTURA DE COMPRA %s" %(factura.id)
        compras = FacturaCompraItem.objects.filter(factura_compra_id=factura.id)
        for compra in compras:
            t_compra = t_compra +  (compra.valor_unitario * compra.cantidad)
            t_iva  = t_iva + (compra.iva * compra.cantidad)
        
        t_total = t_compra + t_iva
        
        factura.subtotal = t_compra
        factura.iva = t_iva
        factura.total = t_total + float(ajuste) + float(retefuente) + float(reteiva) + float(transporte) - float(descuento) + float(reteica) + float(retecre) + float(cuatroxmil)
        factura.save()
        entrada_id = factura.id
    else:
        texto = solicitud.method
    
    facturas = FacturaCompra.objects.filter(configuracion_id=config_id)
    datos = {'texto': texto, 'Facturas' : facturas, 'envia': "Edwar C.", "entrada_id":entrada_id}
    
    return datos
    

@login_required
def entradasBorrar(solicitud):
    texto = 0
    datos = {}
    if solicitud.POST:
        texto = "En post"
        config_id = solicitud.session['config_id']
        try:
            factura_id = solicitud.POST.get('factura_id', 0)
            facturas = FacturaCompra.objects.filter(configuracion_id=config_id, id=factura_id)
            if len(facturas)>0:
                items = FacturaCompraItem.objects.filter(configuracion_id=config_id, factura_compra_id=factura_id)
                if len(items)>0:
                    for item in items:
                        texto = compraBorrarItem(solicitud, item.id)
                tmp_factura = FacturaCompra.objects.get(configuracion_id=config_id, id = factura_id)
                tmp_factura.delete()
                texto = 1
        except:
            texto = "Error borrando la factura."
    return texto
    

@login_required
def facturasCompraBorrarItem(solicitud):
    texto = 0
    if solicitud.POST:
        texto = 0
        item_id = solicitud.POST.get('item')
        texto = compraBorrarItem(solicitud, item_id)
    return HttpResponse(texto)


def compraBorrarItem(solicitud, item_id):
    config_id = solicitud.session['config_id']
    Items = FacturaCompraItem.objects.filter(configuracion_id=config_id, id=item_id)
    if len(Items)>0:
        Item = FacturaCompraItem.objects.get(configuracion_id=config_id, id=item_id)
        Item.delete()
        texto = 1
    else:
        texto = 2
    return HttpResponse(texto)


##########################
# MÓDULOS DE FACTURAS DE VENTA
##########################

@login_required
def bsqProductoDevolucion(solicitud):
    texto = ""
    if solicitud.method == 'POST':
#        texto = "post"
        config_id = solicitud.session['config_id']
        sede_id = solicitud.POST.get('sede_id')
        proveedor_id = solicitud.POST.get('proveedor_id')
        bsq_producto = solicitud.POST.get('producto')
        Productos = Producto.objects.filter(configuracion_id=config_id, nombre__icontains=bsq_producto)
#        texto = len(Productos)
        Compras = FacturaCompra.objects.filter(configuracion_id=config_id, proveedor_id=proveedor_id)
#        texto = "%s sede_id=%s compras=%s" %(texto, sede_id, len(Compras))
        items = FacturaCompraItem.objects.filter(configuracion_id=config_id, producto__in=Productos, factura_compra__in=Compras)
#        texto = "%s items=%s" %(texto, len(items))
        inventario = Inventario.objects.filter(item__in=items, sede_id = sede_id, cantidad__gte=1)
        
        for (i,producto) in enumerate(inventario):
#            Items = Inventario.objects.filter(configuracion_id=config_id, item_id=)
            texto = "%s <a href=\"#\" id=\"resp%s\" value=\"%s\" cantidad=\"%s\" lote=\"%s\" vencimiento=\"%s\" n_proveedor=\"%s\" id_proveedor=\"%s\" onClick=\"copyToBox($('#resp%s'))\">%s</a><br/>" \
                        %(texto, i, producto.item.id, producto.cantidad, producto.item.lote, producto.item.fecha_vencimiento.strftime("%d/%m/%Y"), producto.item.factura_compra.proveedor.nombre, 
                          producto.item.factura_compra.proveedor.id, i, producto.item.producto.nombre)
    return HttpResponse(texto)


@login_required
def bsqProductoVenta(solicitud):
    texto = ""
    if solicitud.method == 'POST':
#        texto = "post"
        config_id = solicitud.session['config_id']
        sede_id = solicitud.POST.get('sede_id')
        bsq_producto = solicitud.POST.get('producto')
        Productos = Producto.objects.filter(configuracion_id=config_id, nombre__icontains=bsq_producto)
        items = FacturaCompraItem.objects.filter(configuracion_id=config_id, producto__in=Productos)
        inventario = Inventario.objects.filter(item__in=items, sede_id = sede_id, cantidad__gte=1)
        
        for (i,producto) in enumerate(inventario):
            texto = "%s <a href=\"#\" id=\"res%s\" value=\"%s\" cantidad=\"%s\" lote=\"%s\" vencimiento=\"%s\" n_proveedor=\"%s\" id_proveedor=\"%s\" vlr_compra=\"%s\" onClick=\"copyToBox($('#res%s'))\">%s</a><br/>" \
                        %(texto, i, producto.item.id, producto.cantidad, producto.item.lote, producto.item.fecha_vencimiento.strftime("%d/%m/%Y"), producto.item.factura_compra.proveedor.nombre, 
                          producto.item.factura_compra.proveedor.id, producto.item.valor_unitario, i, producto.item.producto.nombre)
    return HttpResponse(texto)


@login_required
def devolucionBuscar(solicitud):
    datos={}
    v_devoluciones={}
    i=0
    config_id = solicitud.session['config_id']
    devoluciones = FacturaVenta.objects.filter(configuracion_id=config_id, movimiento_tipo_id=12)
    
    for devolucion in devoluciones:
        items = FacturaVentaItem.objects.filter(factura_venta_id = devolucion.id)
        v_devoluciones[i]={'devolucion':devolucion, 'items':items}
        i=i+1
    texto = len(devoluciones)
    datos = devolucionProducto(solicitud)
    return redireccionar('inventario/salidas/devolucion.html', solicitud, datos)


@login_required
def devolucionProducto(solicitud):
    datos={}
    v_devoluciones={}
    i=0
    config_id = solicitud.session['config_id']
    devoluciones = FacturaVenta.objects.filter(configuracion_id=config_id, movimiento_tipo_id=12)
    
    for devolucion in devoluciones:
        items = FacturaVentaItem.objects.filter(factura_venta_id = devolucion.id)
        v_devoluciones[i]={'devolucion':devolucion, 'items':items}
        i=i+1
    texto = len(devoluciones)
    datos = {'texto': texto, 'Devoluciones' : v_devoluciones, 'envia': "Edwar C."}
    return datos


@login_required
def devolucionNuevo(solicitud, devolucion_id="0"):
#    datos=facturasVenta(solicitud, factura_id)
    config_id = solicitud.session['config_id']
    devoluciones = {}
    items = {}
    
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)

    if devolucion_id != "0":
        devoluciones = FacturaVenta.objects.filter(configuracion_id=config_id, id = devolucion_id)
        if len(devoluciones)>0:
            devoluciones = FacturaVenta.objects.get(configuracion_id=config_id, id = devolucion_id)
            items = FacturaVentaItem.objects.filter(factura_venta_id = devoluciones.id)
        texto = devolucion_id
    else:
        texto = devolucion_id 
    datos = {'Sedes':user_sede, 'texto':texto, 'Devolucion':devoluciones, 'Items':items}
    
    return redireccionar('inventario/salidas/devolucion_nuevo.html', solicitud, datos)


@login_required
def devolucionGuardar(solicitud):
    texto = ""
    id_salida = salidasGuardar(solicitud, 12)
    return HttpResponseRedirect("/inventario/devolucion/")

@login_required
def devolucionBorrar(solicitud):
    texto = salidasBorrar(solicitud)
    return HttpResponse(texto)
    

@login_required
def obsequioBuscar(solicitud):
    datos={}
    obsequio = []
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
    
    tmp_facturas = FacturaVenta.objects.filter(configuracion_id=config_id, movimiento_tipo_id=13)
    
    for sede in user_sede:
        tmp_factura = tmp_facturas.filter(sede_id = sede.sede_id)
        for tmp_fac in tmp_factura:
            obsequio.append(tmp_fac)

    texto = len(obsequio)
    datos = {'texto': texto, 'Obsequios' : obsequio, 'envia': "Edwar C."}
    return redireccionar('inventario/salidas/obsequio.html', solicitud, datos)



@login_required
def obsequioNuevo(solicitud, factura_id="0"):
    datos=facturasVenta(solicitud, factura_id)
    return redireccionar('inventario/salidas/obsequio_nuevo.html', solicitud, datos)


@login_required
def obsequioGuardar(solicitud):
    texto = salidasGuardar(solicitud, 13)
    return HttpResponseRedirect("/inventario/obsequio/")


@login_required
def obsequioBorrar(solicitud):
    texto = salidasBorrar(solicitud)
    return HttpResponse(texto)
    

@login_required
def prestamoBuscar(solicitud):
    datos={}
    config_id = solicitud.session['config_id']
    prestamos = FacturaVenta.objects.filter(configuracion_id=config_id, movimiento_tipo_id=14)
    texto = len(prestamos)
    datos = {'texto': texto, 'Prestamos' : prestamos, 'envia': "Edwar C."}
    return redireccionar('inventario/salidas/prestamo.html', solicitud, datos)


@login_required
def prestamoNuevo(solicitud, factura_id="0"):
    datos=facturasVenta(solicitud, factura_id)
    return redireccionar('inventario/salidas/prestamo_nuevo.html', solicitud, datos)


@login_required
def prestamoGuardar(solicitud):
    texto = salidasGuardar(solicitud, 14)
    return HttpResponseRedirect("/inventario/prestamo/")


@login_required
def prestamoBorrar(solicitud):
    texto = salidasBorrar(solicitud)
    return HttpResponse(texto)


@login_required
def facturasVentaBuscar(solicitud):
    datos={}
    facturas = []
    config_id = solicitud.session['config_id']
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
    
    tmp_facturas = FacturaVenta.objects.filter(configuracion_id=config_id, movimiento_tipo_id=11)
    
    for sede in user_sede:
        tmp_factura = tmp_facturas.filter(sede_id = sede.sede_id)
        for tmp_fac in tmp_factura:
            facturas.append(tmp_fac)
   
    texto = len(facturas)
    datos = {'texto': texto, 'Facturas' : facturas}
    return redireccionar('inventario/salidas/facturas_venta.html', solicitud, datos)


@login_required
def facturasVenta(solicitud, factura_id="0", movimiento_tipo=0):
    config_id = solicitud.session['config_id']
    itemsCompra = {}
    inv = []
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    config_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=user.id)
    if config_user>0:
        config_user = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=user.id)
        user_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=config_user.id)
    
    Productos =Producto.objects.filter(configuracion_id = config_id)
    itemsCompra = FacturaCompraItem.objects.filter(configuracion_id=config_id, producto__in=Productos)
    inventario = Inventario.objects.filter(configuracion_id=config_id, item__in=itemsCompra, cantidad__gte=1)
    
    for sede in user_sede:
        tmp_inventario = inventario.filter(sede_id = sede.sede_id)
        for tmp_inv in tmp_inventario:
            inv.append(tmp_inv)
        
    factura = {'subtotal':0, 'iva':0, 'total':0}
    items = {}
    if factura_id != "0":
        factura = FacturaVenta.objects.filter(configuracion_id=config_id, id = factura_id)
        if len(factura)>0:
            i = 0
            factura = FacturaVenta.objects.get(configuracion_id=config_id, id = factura_id)
            Item = FacturaVentaItem.objects.filter(factura_venta_id = factura_id)
            for item in Item:
                pro_subtotal = item.cantidad * item.valor_unitario
                iva_subtotal = item.cantidad * item.iva
                items[i] = {'item':item, 'pro_subtotal':pro_subtotal, 'iva_subtotal':iva_subtotal}
                i = i+1
             
        texto = factura_id
    else:
        texto = factura_id 
    datos = {'Sedes':user_sede, 'texto':texto, 'Factura':factura, 'Items':items, 'tipo_movimiento': movimiento_tipo, 
             'Productos':inv}
    return datos
    

@login_required
def facturasVentaNuevo(solicitud, factura_id="0"):
    datos=facturasVenta(solicitud, factura_id)
    return redireccionar('inventario/salidas/facturas_venta_nuevo.html', solicitud, datos)


@login_required
def facturasVentaGuardar(solicitud):
    texto = salidasGuardar(solicitud, 11)
    return HttpResponseRedirect("/inventario/facturas_venta/")
#    return HttpResponse(texto)
    

@login_required   
def salidasGuardar(solicitud, movimiento_tipo):
    texto = ""
    id_salida = 0
    
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        session = Session.objects.get(session_key=solicitud.session.session_key)
        uid = session.get_decoded().get('_auth_user_id')
        user = User.objects.get(pk=uid)
        
        sede_id = solicitud.POST.get('sede')
        factura_id = solicitud.POST.get('factura-id')   
        numero = solicitud.POST.get('factura-no', "0")
        cliente = solicitud.POST.get('cliente')
        tmp_emision = solicitud.POST.get('emision')
        orden = solicitud.POST.get('orden-venta')
        vendedor = solicitud.POST.get('vendedor')
        subtotal = solicitud.POST.get('subtotal', "0")
        iva = solicitud.POST.get('iva', "0")
        retefuente = solicitud.POST.get('retefuente', "0")
        reteiva = solicitud.POST.get('reteiva', "0")
        transporte = solicitud.POST.get('transporte', "0")
        ajuste = solicitud.POST.get('vlr_ajuste', "0")
        total = solicitud.POST.get('total', "0")
        pagada = solicitud.POST.get('chk-pagada', "0")
        observaciones = solicitud.POST.get('observaciones')
        subtotal = subtotal.replace(u",", ".")
        iva = iva.replace(u",", ".")
        ajuste = ajuste.replace(u",", ".")
        retefuente = retefuente.replace(u".", "")
        retefuente = retefuente.replace(u",", ".")
        reteiva = reteiva.replace(u".", "")
        reteiva = reteiva.replace(u",", ".")
        transporte = transporte.replace(u".", "")
        transporte = transporte.replace(u",", ".")
        total = total.replace(u",", ".")
        
        if len(ajuste)<1:
            ajuste = 0
        
        if len(retefuente)<1:
            retefuente = 0
        
        if len(reteiva)<1:
            reteiva = 0
            
        if len(transporte)<1:
            transporte = 0
        
        if pagada!=0:
            pagada = 1
        
        texto = "Pagada: %s" %(pagada)
        if tmp_emision != '':
            if int(tmp_emision[6:10]) < 1000:
                anho =  2000 + int(tmp_emision[6:10])
            else:
                anho = int(tmp_emision[6:10])
            emision = date(anho, int(tmp_emision[3:5]), int(tmp_emision[0:2]))
        else:
            emision = date.today()
            
        
        if factura_id != "":
            factura = FacturaVenta.objects.filter(configuracion_id = config_id, id = factura_id)
            if len(factura)>0:
                factura = FacturaVenta.objects.get(configuracion_id = config_id, id = factura_id)
                factura_id = factura.id
            else:
                factura_id = ""
        
        if factura_id == "":
            factura = FacturaVenta(configuracion_id=config_id, movimiento_tipo_id=movimiento_tipo, numero=numero, cliente=cliente, fecha_emision=emision,  
                              sede_id = sede_id, vendedor=vendedor, orden_venta=orden, subtotal=subtotal, iva=iva, ajuste_peso=ajuste, retefuente=retefuente, 
                              reteiva=reteiva, transporte=transporte, total=total, pagada=pagada, observaciones=observaciones)
        else:
            factura = FacturaVenta.objects.get(configuracion_id = config_id, id = factura_id)
            factura.sede_id = sede_id
            factura.numero = numero
            factura.cliente = cliente
            factura.fecha_emision = emision
            factura.vendedor = vendedor
            factura.orden_venta = orden
            factura.subtotal = subtotal
            factura.iva = iva
            factura.ajuste_peso = ajuste
            factura.retefuente = retefuente
            factura.reteiva = reteiva
            factura.transporte = transporte
            factura.total = total
            factura.pagada = pagada
            factura.observaciones = observaciones
        
        factura.save()
        id_salida = factura.id
        campos = solicitud.POST.get('cant_campos')
        
        
        i=0
        no_existe = 0
        while i<int(campos):
            i=i+1
                    
            att = "hdnProducto_%s" %(i)
            for atributo, file in solicitud.POST.iteritems():
                if atributo == att:
                    producto = solicitud.POST.get(att)
                    att = "hdnItem_%s" %(i)
                    item_id = solicitud.POST.get(att)
                    att = "hdnCantidad_%s" %(i)
                    cantidad = solicitud.POST.get(att)
                    
                    att = "hdnUnitario_%s" %(i)
                    unitario = solicitud.POST.get(att, 0)
                    unitario = unitario.replace(u",", ".")
                    att = "hdnIva_%s" %(i)
                    iva = solicitud.POST.get(att, 0)
                    iva = iva.replace(u",", ".")
                    texto = item_id
                    att = ""
                    if item_id == "0":
                        items = FacturaCompraItem.objects.filter(configuracion_id=config_id, id=producto)
                        inventario = Inventario.objects.filter(item__in=items, sede_id=sede_id, cantidad__gte= int(cantidad)-1)
                        
                        texto = "Cantidad = %s Inventario = %s Producto=%s Items=%s" %(cantidad, len(inventario), producto, len(items))
                        if len(inventario)>0:
                            texto = "Guardando item... %s" %(texto)
                            facturaItem = FacturaVentaItem(configuracion_id = config_id, factura_venta_id=factura.id, producto_id=producto, cantidad=cantidad, 
                                                    valor_unitario=unitario, iva=iva)
                            facturaItem.save()
                else:
                    no_existe = no_existe+1
        
#        GUARDAR EL SUBTOTAL, IVA Y TOTAL DE FACTURA EN FUNCIÓN DE LOS ITEMS DE FACTURA
        t_ventas = 0
        t_iva  = 0
        t_total = 0
        
#        texto = " CALCULANDO LA FACTURA DE VENTA %s" %(factura.id)
        ventas = FacturaVentaItem.objects.filter(factura_venta_id=factura.id)
        for venta in ventas:
            t_ventas = t_ventas +  (venta.valor_unitario * venta.cantidad)
            t_iva  = t_iva + (venta.iva * venta.cantidad)
        
        t_total = t_ventas + t_iva
        
        factura.subtotal = t_ventas
        factura.iva = t_iva
        factura.total = t_total + float(ajuste) + float(retefuente) + float(reteiva) + float(transporte)
        factura.save()
        id_salida = factura.id
        
        movimientos = Movimientos.objects.filter(configuracion_id=config_id, tipo_movimiento_id=movimiento_tipo, id_documento=factura.id)
        if len(movimientos)<=0:
            movimiento = Movimientos(configuracion_id=config_id, tipo_movimiento_id=movimiento_tipo, fecha=date.today(), responsable_id=uid, id_documento=factura.id)
            movimiento.save()
    
    else:
        texto = solicitud.method
        id_salida = 0
    return texto
    

@login_required
def salidasBorrar(solicitud):
    texto = "Antes de post"
    if solicitud.POST:
        texto = "En post"
        config_id = solicitud.session['config_id']
        try:
            factura_id = solicitud.POST.get('factura_id', 0)
            facturas = FacturaVenta.objects.filter(configuracion_id=config_id, id=factura_id)
            if len(facturas)>0:
                items = FacturaVentaItem.objects.filter(factura_venta_id=factura_id)
                if len(items)>0:
                    for item in items:
                        texto = ventaBorrarItem(solicitud, item.id)
                tmp_factura = FacturaVenta.objects.get(configuracion_id=config_id, id = factura_id)
                tmp_factura.delete()
                texto = 1
        except:
            texto = "Error borrando la factura."
    return texto


@login_required
def facturasVentaBorrar(solicitud):
    texto = salidasBorrar(solicitud)
    return HttpResponse(texto)
    
    
@login_required
def facturasVentaBorrarItem(solicitud):
    texto = 0
    if solicitud.POST:
        texto = 0
        item_id = solicitud.POST.get('item', 0)
        texto = ventaBorrarItem(solicitud, item_id)
    return HttpResponse(texto)


def ventaBorrarItem(solicitud, item_id):
    config_id = solicitud.session['config_id']
    Items = FacturaVentaItem.objects.filter(configuracion_id=config_id, id=item_id)
    if len(Items)>0:
        Item = FacturaVentaItem.objects.get(configuracion_id=config_id, id=item_id)
        Item.delete()
        texto = 1
    else:
        texto = 2
    return HttpResponse(texto)


##########################
# MÓDULOS DE CONFIGURACIÓN
##########################

@login_required
def usuarios(solicitud, texto=""):
    datos={}
    config_id = solicitud.session['config_id']
    if not inGroup(solicitud, 1):
        return HttpResponseRedirect("/")
    else:
        usuarios = ConfiguracionUsuario.objects.filter(configuracion_id=config_id)
        sedes = Sede.objects.filter(configuracion_id=config_id)
        texto = len(usuarios)
        datos = {'texto': texto, 'Usuarios' : usuarios, 'Sedes':sedes, 'envia': "Edwar C."}
        return redireccionar('configuracion/usuarios.html', solicitud, datos)


@login_required
def usuariosRegistrar(solicitud):
    texto = ""
    usuarios = {}
    existe = False
    c = {}
    datos={}
    usuario_sedes = {}
    grupo = ""
    config_id = solicitud.session['config_id']
    sedes = Sede.objects.filter(configuracion_id=config_id)
    
    grupos = Group.objects.all()
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        usuario_id = solicitud.POST.get('usuario_id')
        
        if usuario_id != "0":
            usuario = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=usuario_id)
            if len(usuario)>0:
                usuarios = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=usuario_id)
                existe = True
                for group in usuarios.usuario.groups.all():
                    grupo = group
                
    i=0           
    for sede in sedes:
        i = i+1
        permiso = False
        if existe:
            tmp_usuario_sede = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=usuarios.id, sede_id=sede.id)
            if len(tmp_usuario_sede)>0:
                permiso = True
        usuario_sedes[i] = {'sede':sede, 'permiso':permiso}
    datos = {'usuarios':usuarios, 'texto':texto, 'Sedes':usuario_sedes, 'Grupos':grupos, 'Grupo':grupo}
#    texto = len(usuarios)
    return redireccionar('configuracion/usuarios_nuevo.html', solicitud, datos)


@login_required
def usuariosVerificar(solicitud):
    texto = 0
    usuarios = {}
    c = {}
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        username = solicitud.POST.get('usuario')
        usuarios = User.objects.filter(username=username)
        if len(usuarios)>0:
            config_usuarios = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario__in=usuarios)
            if len(config_usuarios)>0:
                texto = 1
            else:
                texto = 2
    else:
        texto = -1
    
#    texto = len(usuarios)
    return HttpResponse(texto)


@login_required
def usuariosGuardar(solicitud):
    texto = ""
    c = {}
    guardo=False
    config_id = solicitud.session['config_id']
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        
        cedula = solicitud.POST.get('usuario-identificacion')
        first_name = solicitud.POST.get('usuario-nombres')
        last_name = solicitud.POST.get('usuario-apellidos')
        telefono = solicitud.POST.get('usuario-telefono')
        email = solicitud.POST.get('usuario-email')
        username = solicitud.POST.get('usuario-usuario')
        password = solicitud.POST.get('usuario-contrasena')
        perfil = solicitud.POST.get('perfil')
        
        texto = "Listo para guardar"
        usuarios = User.objects.filter(username=username)
        if len(usuarios)>0:
            usuario = User.objects.get(username=username)
            usuario.first_name = first_name
            usuario.last_name = last_name
            usuario.email = email
            if password.strip() != "":
                usuario.set_password(password)
            usuario.groups.clear()
            usuario.groups.add(perfil)
            usuario.save()
            
            conf_user = ConfiguracionUsuario.objects.get(configuracion_id = config_id, usuario_id = usuario.id)
            conf_user.identificacion = cedula
            conf_user.telefono = telefono
            conf_user.save()
            guardo=True
        else:
            usuario = User(username=username, first_name=first_name, last_name=last_name, email=email)
            usuario.save()
            usuario.set_password(password)
            usuario.groups.clear()
            usuario.groups.add(perfil)
            usuario.save()
            texto = "Guardó usuario"
            conf_user = ConfiguracionUsuario(configuracion_id = config_id, usuario_id = usuario.id, identificacion=cedula, telefono=telefono)
            conf_user.save()
            texto = "Guardó config"
            guardo=True
        
        if guardo:
            conf_user_sedes = ConfiguracionUsuarioSede.objects.filter(configuracion_usuario_id=conf_user.id)
            conf_user_sedes.delete()
            
            sedes = Sede.objects.filter(configuracion_id = config_id)
            for sede in sedes:
                att = "chk_%s" %(sede.id)
                sede_sel = solicitud.POST.get(att, 0)
                if sede_sel != 0:
                    conf_user_sede=ConfiguracionUsuarioSede(configuracion_usuario_id = conf_user.id, sede_id=sede.id)
                    conf_user_sede.save()
                
    else:
        texto = solicitud.method
        
    usuarios = ConfiguracionUsuario.objects.filter(configuracion_id=config_id)
    datos = {'texto': texto, 'Usuarios' : usuarios,
             'envia': "Edwar C."}
    return redireccionar('configuracion/usuarios.html', solicitud, datos)
#    return HttpResponse(texto)


@login_required
def usuariosBorrar(solicitud):
    texto = "Antes de post"
    if solicitud.POST:
        texto = "En post"
        config_id = solicitud.session['config_id']
#        try:
        conf_user = ConfiguracionUsuario.objects.filter(configuracion_id=config_id)
        for usuario in conf_user:
            chk = u"%s_%s" %('chk', usuario.usuario_id)
            seleccionado = solicitud.POST.get(chk, 0)
            texto = "%s usuario_id: %s chk: %s" %(texto, usuario.usuario_id, chk)
            if seleccionado != 0:
                texto = "%s usuario_id: %s chk: %s" %(texto, usuario.usuario_id, chk)
                conf = ConfiguracionUsuario.objects.filter(configuracion_id=config_id, usuario_id=usuario.usuario_id)
                if len(conf)<=1:
                    tmp_conf = ConfiguracionUsuario.objects.get(configuracion_id=config_id, usuario_id=usuario.usuario_id)
                    tmp_conf.delete()
                    tmp_conf = User.objects.get(id = usuario.usuario_id)
                    tmp_conf.delete()
                    
                else:
                    texto = "No se puede borrar el usuario, está siendo usado por otra empresa."
#    return HttpResponse(texto)
    return HttpResponseRedirect("/configuracion/usuarios/")


@login_required
def configuracion(solicitud, texto=""):
    config_id = solicitud.session['config_id']
    if not inGroup(solicitud, 1):
        return HttpResponseRedirect("/")
    else:
        configuracion = Configuracion.objects.filter(id=config_id)
        if len(configuracion)>0:
            configuracion = Configuracion.objects.get(id=config_id)
        else:
            configuracion = {}
        
        categorias = Categoria.objects.filter(configuracion_id = config_id)
        unidades = Unidad.objects.filter(configuracion_id = config_id)
        iva = Iva.objects.filter(configuracion_id = config_id)
        sedes = Sede.objects.filter(configuracion_id = config_id)
        datos = {'Categorias': categorias, 'Unidades':unidades, 'configuracion':configuracion, 'Sedes':sedes, 'texto':texto, 'Iva':iva}
        return redireccionar('configuracion.html', solicitud, datos)
        
    
@login_required
def configuracionGuardar(solicitud):
    c = {}
    texto = ""
    logo = ""
    c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken')))
    config_id = solicitud.session['config_id']
    
    session = Session.objects.get(session_key=solicitud.session.session_key)
    uid = session.get_decoded().get('_auth_user_id')
    user = User.objects.get(pk=uid)
    
    nit = solicitud.POST.get('nit')
    nombre = solicitud.POST.get('nombre')
    
    for filename, file in solicitud.FILES.iteritems():
        logo = solicitud.FILES[filename].name
        logo = solicitud.FILES['foto']

    direccion = solicitud.POST.get('direccion')
    telefono = solicitud.POST.get('telefono')
    fax = solicitud.POST.get('fax')
    web = solicitud.POST.get('web')
    email = solicitud.POST.get('email')
    contrasena_actual = solicitud.POST.get('contrasena-actual')
    contrasena_nueva = solicitud.POST.get('contrasena-nueva')
    
    config = Configuracion.objects.filter(id=config_id)
    if len(config)>0:
        config = Configuracion.objects.get(id=config_id)
        config.nit = nit
        config.nombre = nombre
        config.logo = logo
        config.direccion = direccion
        config.telefono = telefono
        config.fax = fax
        config.web = web
        config.email = email
        
        if email.strip() != "":
            user.email = email
            if contrasena_actual.strip() != "" and contrasena_nueva.strip()!="":
                tmp_user = authenticate(username=user.username, password=contrasena_actual)
                if tmp_user is not None:
                    texto = "Contraseña actualizada."
                    user.set_password(contrasena_nueva)
                else:
                    texto = "La contraseña no ha sido modificada. La contraseña actual no coincide."
            user.save()
        
    else:
        config = Configuracion(nit=nit, nombre=nombre, direccion=direccion,
                                      telefono=telefono, fax=fax, web=web, email=email)
   
    texto = logo     
    config.save()
    return configuracion(solicitud, texto)


@login_required
def notificacionGuardar(solicitud):
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
           
        correo = solicitud.POST.get('correo')
        Notificacion = Notificaciones.objects.filter(configuracion_id = config_id)
        if len(Notificacion) > 0:
            notif = Notificaciones.objects.get(configuracion_id = config_id)
            notif.correo = correo
            notif.save()
        else:
            notif = Notificaciones(configuracion_id = config_id, correo = correo)
            notif.save()
        
    return HttpResponseRedirect("/")
    
@login_required
def configuracionCategorias(solicitud):
    texto = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
           
        nombre = solicitud.POST.get('categoria-nombre')
        abrev = solicitud.POST.get('categoria-abrev')
        categoria_id = solicitud.POST.get('categoria-id')
        sismed = solicitud.POST.get('chk-categoria-sismed', 0)
        dias = solicitud.POST.get('dias-vencimiento', 0)
        if sismed != 0:
            sismed = 1
        
        texto = categoria_id
        if categoria_id != "":
            categ = Categoria.objects.filter(configuracion_id=config_id, id=categoria_id)
            if len(categ)>0:
                categ = Categoria.objects.get(configuracion_id=config_id, id=categoria_id)
                categoria_id = categ.id
            else:
                categoria_id = ""
        
        if categoria_id != "":
            categ = Categoria.objects.get(configuracion_id=config_id, id=categoria_id)
            categ.nombre = nombre
            categ.abrev = abrev
            categ.sismed = sismed
            categ.dias_vencimiento = dias
            categ.save()
        else:
            categoria = Categoria(configuracion_id = config_id, nombre=nombre, abrev=abrev, sismed=sismed, dias_vencimiento=dias)
            categoria.save()
    else:
        texto = solicitud.method
    
#    return HttpResponse(texto)
    return configuracion(solicitud, texto)


@login_required
def configuracionCategoriasNuevo(solicitud, texto=""):
    datos={}
    c = {}
    categorias = {}
    config_id = solicitud.session['config_id']
    
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        categoria_id = solicitud.POST.get('categoria_id')
        
        if categoria_id != "0":
            categorias = Categoria.objects.filter(configuracion_id=config_id, id=categoria_id)
            if len(categorias)>0:
                categorias = Categoria.objects.get(configuracion_id=config_id, id=categoria_id)
                texto = categorias.nombre
        
    datos = {'texto': texto, 'Categorias' : categorias, 'envia': "Edwar C."}
    return redireccionar('configuracion/categoria_nuevo.html', solicitud, datos)


@login_required
def configuracionCategoriasBorrar(solicitud):
    if solicitud.POST:
        texto = ""
        config_id = solicitud.session['config_id']
        
        try:
            categorias = Categoria.objects.filter(configuracion_id=config_id)
            for categoria in categorias:
                chk = u"%s_%s" %('chk', categoria.id)
                categoria_seleccionada = solicitud.POST.get(chk, 0)
                if categoria_seleccionada != 0:
                    productos = Producto.objects.filter(configuracion_id=config_id, categoria_id=categoria.id)
                    if len(productos)<1:
                        tmp_categoria = Categoria.objects.get(id = categoria.id)
                        tmp_categoria.delete()
                    else:
                        texto = "La categoría no puede ser borrada porque está asignada a %s productos." %(len(productos))
        except:
            texto = "Error"
    return configuracion(solicitud, texto)


@login_required
def configuracionUnidades(solicitud):
    texto = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
           
        nombre = solicitud.POST.get('unidad-nombre')
        abrev = solicitud.POST.get('unidad-abrev')
        unidad_id = solicitud.POST.get('unidad-id')
        
        if unidad_id != "":
            unidades = Unidad.objects.filter(configuracion_id = config_id, id=unidad_id)
            if len(unidades)>0:
                unidades = Unidad.objects.get(configuracion_id = config_id, id=unidad_id)
                unidad_id = unidades.id
            else:
                unidad_id = ""
        
        if unidad_id != "":
            unidad = Unidad.objects.get(configuracion_id = config_id, id=unidad_id)
            unidad.nombre = nombre
            unidad.abrev = abrev
            unidad.save()
        else:
            unidad = Unidad(configuracion_id = config_id, nombre=nombre, abrev=abrev)
            unidad.save()
    else:
        texto = solicitud.method
    
    return configuracion(solicitud, texto)

@login_required
def configuracionUnidadesNuevo(solicitud, texto=""):
    datos={}
    c = {}
    unidades = {}
    config_id = solicitud.session['config_id']
    
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken')))
        unidades = Unidad.objects.filter(configuracion_id=config_id) 
        unidad_id = solicitud.POST.get('unidad_id')
        
        if unidad_id != "0":
            unidades = Unidad.objects.filter(configuracion_id=config_id, id=unidad_id)
            if len(unidades)>0:
                unidades = Unidad.objects.get(configuracion_id=config_id, id=unidad_id)
                texto = unidades.nombre
        
    datos = {'texto': texto, 'Unidad' : unidades, 'envia': "Edwar C."}
    return redireccionar('configuracion/unidades_nuevo.html', solicitud, datos)


@login_required
def configuracionUnidadesBorrar(solicitud):
    if solicitud.POST:
        texto = ""
        config_id = solicitud.session['config_id']
        
        try:
            unidades = Unidad.objects.filter(configuracion_id=config_id)
            for unidad in unidades:
                chk = u"%s_%s" %('chk', unidad.id)
                unidad_seleccionada = solicitud.POST.get(chk, 0)
                if unidad_seleccionada != 0:
                    productos = Producto.objects.filter(configuracion_id=config_id, unidad_id=unidad.id)
                    if len(productos)<1:
                        tmp_unidad = Unidad.objects.get(id = unidad.id)
                        tmp_unidad.delete()
                    else:
                        texto = "La unidad no puede ser borrada porque está asignada a %s productos." %(len(productos))
        except:
            texto = "Error"
    return configuracion(solicitud, texto)


@login_required
def configuracionIva(solicitud):
    texto = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
           
        nombre = solicitud.POST.get('iva-nombre')
        valor = solicitud.POST.get('iva-valor')
        iva_id = solicitud.POST.get('iva-id')
        
        if iva_id != "":
            unidades = Iva.objects.filter(configuracion_id = config_id, id=iva_id)
            if len(unidades)>0:
                iva = Iva.objects.get(configuracion_id = config_id, id=iva_id)
                iva_id = unidades.id
            else:
                iva_id = ""
        
        if iva_id != "":
            iva = Iva.objects.get(configuracion_id = config_id, id=iva_id)
            iva.nombre = nombre
            iva.valor = valor
            iva.save()
        else:
            iva = Iva(configuracion_id = config_id, nombre=nombre, valor=valor)
            iva.save()
    else:
        texto = solicitud.method
    
    return configuracion(solicitud, texto)

@login_required
def configuracionIvaNuevo(solicitud, texto=""):
    datos={}
    c = {}
    unidades = {}
    config_id = solicitud.session['config_id']
    
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken')))
        iva = Iva.objects.filter(configuracion_id=config_id) 
        iva_id = solicitud.POST.get('iva_id')
        
        if iva_id != "0":
            iva = Unidad.objects.filter(configuracion_id=config_id, id=iva_id)
            if len(unidades)>0:
                iva = Unidad.objects.get(configuracion_id=config_id, id=iva_id)
                texto = unidades.nombre
        
    datos = {'texto': texto, 'Iva' : iva, 'envia': "Edwar C."}
    return redireccionar('configuracion/iva_nuevo.html', solicitud, datos)


@login_required
def configuracionIvaBorrar(solicitud):
    if solicitud.POST:
        texto = ""
        config_id = solicitud.session['config_id']
        
        try:
            ivas = Unidad.objects.filter(configuracion_id=config_id)
            for iva in ivas:
                chk = u"%s_%s" %('chk', iva.id)
                iva_seleccionado = solicitud.POST.get(chk, 0)
                tmp_iva = Iva.objects.get(id = iva.id)
                tmp_iva.delete()
        except:
            texto = "Error"
    return configuracion(solicitud, texto)


@login_required
def Sedes(solicitud):
    texto = ""
    if solicitud.method == 'POST':
        config_id = solicitud.session['config_id']
           
        nombre = solicitud.POST.get('sede-nombre')
        abrev = solicitud.POST.get('sede-abrev')
        direccion = solicitud.POST.get('sede-direccion')
        telefono = solicitud.POST.get('sede-telefono')
        fax = solicitud.POST.get('sede-fax')
        email = solicitud.POST.get('sede-email')
        sede_id = solicitud.POST.get('sede-id')
               
               
        if sede_id != "":
            sedes = Sede.objects.filter(configuracion_id = config_id, id=sede_id)
            if len(sedes)>0:
                sedes = Sede.objects.get(configuracion_id = config_id, id=sede_id)
                sede_id = sedes.id
            else:
                sede_id = ""
        
        if sede_id != "":
            sedes = Sede.objects.get(configuracion_id = config_id, id=sede_id)
            sedes.nombre = nombre
            sedes.abrev = abrev
            sedes.direccion = direccion
            sedes.telefono = telefono
            sedes.fax = fax
            sedes.email = email
            sedes.save()
        else:
            sede = Sede(configuracion_id = config_id, nombre=nombre, abrev=abrev, direccion=direccion, telefono=telefono, fax=fax, email=email)
            sede.save()
    else:
        texto = solicitud.method
    
    return configuracion(solicitud, texto)


@login_required
def SedesNuevo(solicitud, texto=""):
    datos={}
    c = {}
    sedes = {}
    config_id = solicitud.session['config_id']
    sedes = Sede.objects.filter(configuracion_id=config_id)
    
    if solicitud.method == 'POST':
        c.update(csrf(solicitud.POST.get('csrfmiddlewaretoken'))) 
        sede_id = solicitud.POST.get('sede_id')
        
        if sede_id != "0":
            sedes = Sede.objects.filter(configuracion_id=config_id, id=sede_id)
            if len(sedes)>0:
                sedes = Sede.objects.get(configuracion_id=config_id, id=sede_id)
                texto = sedes.nombre
        
    datos = {'texto': texto, 'Sedes' : sedes, 'envia': "Edwar C."}
    return redireccionar('configuracion/sede_nuevo.html', solicitud, datos)


@login_required
def SedesBorrar(solicitud):
    if solicitud.POST:
        texto = ""
        config_id = solicitud.session['config_id']
        
        try:
            sedes = Sede.objects.filter(configuracion_id=config_id)
            for sede in sedes:
                chk = u"%s_%s" %('chk', sede.id)
                sede_seleccionada = solicitud.POST.get(chk, 0)
                texto = "%s: %s" %(texto, sede_seleccionada)
                if sede_seleccionada != 0:
                    item = Inventario.objects.filter(configuracion_id=config_id, sede_id=sede.id)
                    if len(item)<1:
                        tmp_unidad = Sede.objects.get(id = sede.id)
                        tmp_unidad.delete()
                    else:
                        texto = "La sede no puede ser borrada porque está asignada a %s productos." %(len(item))
        except:
            texto = "Error %s" %(texto)
    return configuracion(solicitud, texto)


@login_required
def dbbackup(request):
    if not (request.user.is_authenticated() and request.user.is_staff):
        raise http.Http404
#    os.popen3("mysqldump --add-drop-table -u arawak_inventari -p eab528bb arawak_inventari >  backup.sql")
    os.popen3("mysqldump -u arawak_inventari -p eab528bb arawak_inventari >   $HOME/db_backups/backup.sql")
    os.popen3("gzip -c /home/arawak/db_backups/backup.sql")
#    dataf = open('$HOME/db_backups/backup.gz', 'r')
    dataf = open('/home/arawak/db_backups/backup.gz', 'r')
    return HttpResponse(dataf.read(), mimetype='application/x-gzip')